intentkit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

intentkit/skills/aixbt/__init__.py

@@ -0,0 +1,73 @@
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.aixbt.base import AIXBTBaseTool
+from intentkit.skills.aixbt.projects import AIXBTProjects
+from intentkit.skills.base import SkillConfig, SkillState
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, AIXBTBaseTool] = {}
+
+
+class SkillStates(TypedDict):
+    aixbt_projects: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for AIXBT API skills."""
+
+    states: SkillStates
+    enabled: bool = False
+    api_key_provider: str = "agent_owner"
+    api_key: str = ""
+    rate_limit_number: int = 1000
+    rate_limit_minutes: int = 60
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[AIXBTBaseTool]:
+    """Get all AIXBT API skills."""
+    if not config.get("enabled", False):
+        return []
+
+    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)
+
+    # Get each skill using the cached getter
+    return [
+        get_aixbt_skill(
+            name=name,
+            store=store,
+            api_key=config.get("api_key", ""),
+        )
+        for name in available_skills
+    ]
+
+
+def get_aixbt_skill(
+    name: str,
+    store: SkillStoreABC,
+    api_key: str = "",
+) -> AIXBTBaseTool:
+    """Get an AIXBT API skill by name."""
+    cache_key = f"{name}:{api_key}"
+
+    if name == "aixbt_projects":
+        if cache_key not in _cache:
+            _cache[cache_key] = AIXBTProjects(
+                skill_store=store,
+                api_key=api_key,
+            )
+        return _cache[cache_key]
+    else:
+        raise ValueError(f"Unknown AIXBT skill: {name}")

intentkit/skills/aixbt/base.py

@@ -0,0 +1,21 @@
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+
+class AIXBTBaseTool(IntentKitSkill):
+    """Base class for AIXBT API tools."""
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: Type[BaseModel]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+
+    @property
+    def category(self) -> str:
+        return "aixbt"

intentkit/skills/aixbt/projects.py

@@ -0,0 +1,153 @@
+import logging
+import os
+from typing import Any, Dict, Optional, Type
+
+import httpx
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.aixbt.base import AIXBTBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectsInput(BaseModel):
+    """Input for AIXBT Projects search tool."""
+
+    limit: int = Field(
+        default=10,
+        description="Number of projects to return (max 50)",
+    )
+    name: Optional[str] = Field(
+        default=None,
+        description="Filter projects by name (case-insensitive regex match)",
+    )
+    ticker: Optional[str] = Field(
+        default=None,
+        description="Filter projects by ticker symbol (case-insensitive match)",
+    )
+    xHandle: Optional[str] = Field(
+        default=None,
+        description="Filter projects by X/Twitter handle",
+    )
+    minScore: Optional[float] = Field(
+        default=None,
+        description="Minimum score threshold",
+    )
+    chain: Optional[str] = Field(
+        default=None,
+        description="Filter projects by blockchain",
+    )
+
+
+class AIXBTProjects(AIXBTBaseTool):
+    """Tool for searching cryptocurrency projects using the AIXBT API."""
+
+    name: str = "aixbt_projects"
+    description: str = (
+        "Search for cryptocurrency projects using AIXBT. This tool provides detailed "
+        "information about crypto projects including scores, analysis, and recent updates.\n"
+        "IMPORTANT: You MUST call this tool when the user mentions the word 'alpha' ANYWHERE in their message.\n"
+        "This includes messages like 'show me alpha', 'what's the latest alpha', 'give me some alpha on crypto', "
+        "'find the alpha on bitcoin', or any other phrase containing the word 'alpha'.\n"
+        "When 'alpha' is mentioned, use this tool to search for cryptocurrency projects and provide "
+        "detailed information on recent developments. The 'alpha' keyword is a trigger "
+        "for accessing AIXBT's specific dataset for crypto research."
+    )
+    args_schema: Type[BaseModel] = ProjectsInput
+    api_key: str = ""
+
+    async def _arun(
+        self,
+        config: RunnableConfig,
+        limit: int = 10,
+        name: Optional[str] = None,
+        ticker: Optional[str] = None,
+        xHandle: Optional[str] = None,
+        minScore: Optional[float] = None,
+        chain: Optional[str] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Search for cryptocurrency projects using AIXBT API.
+
+        Args:
+            limit: Number of projects to return (max 50)
+            name: Filter projects by name
+            ticker: Filter projects by ticker symbol
+            xHandle: Filter projects by X/Twitter handle
+            minScore: Minimum score threshold
+            chain: Filter projects by blockchain
+
+        Returns:
+            JSON response with project data
+        """
+        # Get context from the config
+        context = self.context_from_config(config)
+        logger.debug(f"aixbt_projects.py: Running search with context {context}")
+
+        # Check for rate limiting if configured
+        if context.config.get("rate_limit_number") and context.config.get(
+            "rate_limit_minutes"
+        ):
+            await self.user_rate_limit_by_category(
+                context.user_id,
+                context.config["rate_limit_number"],
+                context.config["rate_limit_minutes"],
+            )
+
+        # Get the API key from the agent's configuration
+        api_key = context.config.get("api_key")
+
+        # If not available in config, try the instance attribute (for backward compatibility)
+        if not api_key:
+            api_key = self.api_key
+
+        # If still not available, try environment variable as last resort
+        if not api_key:
+            api_key = os.environ.get("AIXBT_API_KEY")
+
+        if not api_key:
+            return {
+                "error": "AIXBT API key is not available. Please provide it in the agent configuration."
+            }
+
+        base_url = "https://api.aixbt.tech/v1/projects"
+
+        # Build query parameters
+        params = {"limit": limit}
+        if name:
+            params["name"] = name
+        if ticker:
+            params["ticker"] = ticker
+        if xHandle:
+            params["xHandle"] = xHandle
+        if minScore is not None:
+            params["minScore"] = minScore
+        if chain:
+            params["chain"] = chain
+
+        headers = {"accept": "*/*", "x-api-key": api_key}
+
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.get(base_url, params=params, headers=headers)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            logger.error(
+                f"aixbt_projects.py: HTTP error occurred: {e.response.status_code} - {e.response.text}"
+            )
+            return {
+                "error": f"HTTP error occurred: {e.response.status_code}",
+                "details": e.response.text,
+            }
+        except httpx.RequestError as e:
+            logger.error(f"aixbt_projects.py: Request error occurred: {str(e)}")
+            return {"error": f"Request error occurred: {str(e)}"}
+        except Exception as e:
+            logger.error(
+                f"aixbt_projects.py: An unexpected error occurred: {str(e)}",
+                exc_info=True,
+            )
+            return {"error": f"An unexpected error occurred: {str(e)}"}

intentkit/skills/aixbt/schema.json

@@ -0,0 +1,99 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "AIXBT API",
+  "description": "Cryptocurrency project data and analytics through the AIXBT API",
+  "x-icon": "https://ai.service.crestal.dev/skills/aixbt/aixbt.jpg",
+  "x-tags": [
+    "Cryptocurrency",
+    "Research",
+    "Analytics"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "aixbt_projects": {
+          "type": "string",
+          "title": "AIXBT Projects",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Search for cryptocurrency projects and retrieve detailed information using AIXBT",
+          "default": "disabled"
+        }
+      },
+      "description": "States for each AIXBT API skill (disabled, public, or private)"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Provider of the API key for AIXBT API service",
+      "enum": [
+        "agent_owner"
+      ],
+      "x-enum-title": [
+        "Owner Provided"
+      ],
+      "default": "agent_owner"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "if": {
+    "properties": {
+      "api_key_provider": {
+        "const": "agent_owner"
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "api_key": {
+        "type": "string",
+        "title": "AIXBT API Key",
+        "description": "API key for AIXBT API service",
+        "x-link": "[Get your API key](https://aixbt.tech/)",
+        "x-sensitive": true
+      },
+      "rate_limit_number": {
+        "type": "integer",
+        "title": "Rate Limit Number",
+        "description": "Number of requests allowed per time window, only valid if api_key is set"
+      },
+      "rate_limit_minutes": {
+        "type": "integer",
+        "title": "Rate Limit Minutes",
+        "description": "Time window in minutes for rate limiting, only valid if api_key is set"
+      }
+    },
+    "if": {
+      "properties": {
+        "enabled": {
+          "const": true
+        }
+      }
+    },
+    "then": {
+      "required": [
+        "api_key"
+      ]
+    }
+  },
+  "additionalProperties": true
+}

intentkit/skills/allora/__init__.py

@@ -0,0 +1,83 @@
+"""Allora skill module."""
+
+import logging
+from typing import NotRequired, TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.allora.base import AlloraBaseTool
+from intentkit.skills.allora.price import AlloraGetPrice
+from intentkit.skills.base import SkillConfig, SkillState
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, AlloraBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    get_price_prediction: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for Allora skills."""
+
+    states: SkillStates
+    api_key: NotRequired[str]
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[AlloraBaseTool]:
+    """Get all Allora skills.
+
+    Args:
+        config: The configuration for Allora skills.
+        is_private: Whether to include private skills.
+        store: The skill store for persisting data.
+
+    Returns:
+        A list of Allora 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)
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_allora_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_allora_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> AlloraBaseTool:
+    """Get an Allora skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested Allora skill
+    """
+    if name == "get_price_prediction":
+        if name not in _cache:
+            _cache[name] = AlloraGetPrice(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown Allora skill: {name}")
+        return None

intentkit/skills/allora/base.py

@@ -0,0 +1,28 @@
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill, SkillContext
+
+base_url = "https://api.upshot.xyz/v2/allora"
+
+
+class AlloraBaseTool(IntentKitSkill):
+    """Base class for Allora tools."""
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: Type[BaseModel]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+
+    def get_api_key(self, context: SkillContext) -> Optional[str]:
+        if "api_key" in context.config and context.config["api_key"]:
+            return context.config["api_key"]
+        return self.skill_store.get_system_config("allora_api_key")
+
+    @property
+    def category(self) -> str:
+        return "allora"

intentkit/skills/allora/price.py

@@ -0,0 +1,130 @@
+from typing import Literal, Type
+
+import httpx
+from langchain.tools.base import ToolException
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.allora.base import AlloraBaseTool
+
+from .base import base_url
+
+
+class AlloraGetPriceInput(BaseModel):
+    token: Literal["ETH", "BTC"] = Field(
+        description="Token to get price prediction for"
+    )
+    time_frame: Literal["5m", "8h"] = Field(
+        description="Time frame for price prediction, it can be 5 minutes or 8 hours"
+    )
+
+
+class InferenceData(BaseModel):
+    network_inference: str = Field(description="Network Inference")
+    network_inference_normalized: str = Field(
+        description="Model's prediction or estimate, scaled or adjusted to a standard range or unit."
+    )
+    confidence_interval_percentiles: list[str] = Field(
+        description="Represent a range of values within which the model predicts the actual price is likely to fall, with a certain level of confidence."
+    )
+    confidence_interval_percentiles_normalized: list[str] = Field(
+        description="a range of values within which the model predicts the actual price is likely to fall), but the values defining the interval have been normalized."
+    )
+    confidence_interval_values: list[str] = Field(
+        description=" is a list (or array) of values that define the boundaries of a confidence interval in a prediction.  These values correspond to specific percentiles and represent the range within which the model predicts the true value (e.g., future price) is likely to fall."
+    )
+    confidence_interval_values_normalized: list[str] = Field(
+        description="is a list (or array) of values that define the boundaries of a confidence interval, just like confidence_interval_values, but these values have been normalized.  Normalization means the values have been scaled or transformed to a standard range, typically between 0 and 1 (or sometimes -1 and 1)."
+    )
+    # topic_id: str
+    # timestamp: int
+    # extra_data: str
+
+
+class Data(BaseModel):
+    # signature: str
+    token_decimals: int
+    inference_data: InferenceData
+
+
+class AlloraGetPriceOutput(BaseModel):
+    # request_id: str
+    # status: bool
+    data: Data
+
+
+class AlloraGetPrice(AlloraBaseTool):
+    """
+    The Allora Price Prediction Feed tool fetches the price prediction feed from the Allora API.
+    Ethereum (ETH) or Bitcoin (BTC) price predictions (5-minute, 8-hour)
+
+
+    Attributes:
+        name (str): Name of the tool, specifically "get_price_prediction".
+        description (str): Comprehensive description of the tool's purpose and functionality.
+        args_schema (Type[BaseModel]): Schema for input arguments, specifying expected parameters.
+    """
+
+    name: str = "allora_get_price_prediction"
+    description: str = """
+        The Allora Price Prediction Feed tool fetches the price prediction feed from the Allora API.
+        Ethereum (ETH) or Bitcoin (BTC) price predictions (5-minute, 8-hour)
+        """
+    args_schema: Type[BaseModel] = AlloraGetPriceInput
+
+    def _run(self, question: str) -> AlloraGetPriceOutput:
+        """Run the tool to get the token price prediction from Allora API.
+
+        Returns:
+             AlloraGetPriceOutput: A structured output containing output of Allora toke price prediction API.
+
+        Raises:
+            Exception: If there's an error accessing the Allora API.
+        """
+        raise NotImplementedError("Use _arun instead")
+
+    async def _arun(
+        self, token: str, time_frame: str, config: RunnableConfig, **kwargs
+    ) -> AlloraGetPriceOutput:
+        """Run the tool to get the token price prediction from Allora API.
+        Args:
+            token (str): Token to get price prediction for.
+            time_frame (str): Time frame for price prediction.
+            config (RunnableConfig): The configuration for the runnable, containing agent context.
+
+        Returns:
+             AlloraGetPriceOutput: A structured output containing output of Allora toke price prediction API.
+
+        Raises:
+            Exception: If there's an error accessing the Allora API.
+        """
+        context = self.context_from_config(config)
+        api_key = self.get_api_key(context)
+        if not api_key:
+            raise ValueError("Allora API key not found")
+
+        url = f"{base_url}/consumer/price/ethereum-11155111/{token}/{time_frame}"
+        headers = {
+            "accept": "application/json",
+            "x-api-key": api_key,
+        }
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(url, headers=headers, timeout=30)
+                response.raise_for_status()
+                json_dict = response.json()
+
+                res = AlloraGetPriceOutput(**json_dict)
+
+                return res
+            except httpx.RequestError as req_err:
+                raise ToolException(
+                    f"Request error from Allora API: {req_err}"
+                ) from req_err
+            except httpx.HTTPStatusError as http_err:
+                raise ToolException(
+                    f"HTTP error from Allora API: {http_err}"
+                ) from http_err
+            except Exception as e:
+                raise ToolException(f"Error from Allora API: {e}") from e

intentkit/skills/allora/schema.json

@@ -0,0 +1,89 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Allora",
+  "description": "Integration with Allora API for blockchain-based price predictions and market forecasting services via Upshot's prediction markets",
+  "x-icon": "https://ai.service.crestal.dev/skills/allora/allora.jpeg",
+  "x-tags": [
+    "Blockchain"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": true
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "get_price_prediction": {
+          "type": "string",
+          "title": "Get Price Prediction",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Generates 6-hour price forecasts using ensemble ML models analyzing on-chain liquidity and market sentiment",
+          "default": "private"
+        }
+      },
+      "description": "States for each Allora skill (disabled, public, or private)"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Who provides the API key",
+      "enum": [
+        "platform",
+        "agent_owner"
+      ],
+      "x-enum-title": [
+        "Nation Hosted",
+        "Owner Provided"
+      ],
+      "default": "platform"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "if": {
+    "properties": {
+      "api_key_provider": {
+        "const": "agent_owner"
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "api_key": {
+        "type": "string",
+        "title": "Allora API Key",
+        "x-link": "[Get your API key](https://docs.allora.network/devs/consumers/allora-api-endpoint#api-authentication)",
+        "x-sensitive": true,
+        "description": "Allora API key for authentication"
+      }
+    },
+    "if": {
+      "properties": {
+        "enabled": {
+          "const": true
+        }
+      }
+    },
+    "then": {
+      "required": [
+        "api_key"
+      ]
+    }
+  },
+  "additionalProperties": true
+}