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

intentkit/skills/portfolio/wallet_swaps.py

@@ -0,0 +1,147 @@
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.portfolio.base import PortfolioBaseTool
+from intentkit.skills.portfolio.constants import (
+    DEFAULT_CHAIN,
+    DEFAULT_LIMIT,
+    DEFAULT_ORDER,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class WalletSwapsInput(BaseModel):
+    """Input for wallet swaps tool."""
+
+    address: str = Field(description="The wallet address to get swap transactions for.")
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+    cursor: Optional[str] = Field(
+        description="The cursor for pagination.",
+        default=None,
+    )
+    limit: Optional[int] = Field(
+        description="The number of results per page.",
+        default=DEFAULT_LIMIT,
+    )
+    from_block: Optional[str] = Field(
+        description="The minimum block number to get transactions from.",
+        default=None,
+    )
+    to_block: Optional[str] = Field(
+        description="The maximum block number to get transactions from.",
+        default=None,
+    )
+    from_date: Optional[str] = Field(
+        description="The start date to get transactions from (format in seconds or datestring).",
+        default=None,
+    )
+    to_date: Optional[str] = Field(
+        description="The end date to get transactions from (format in seconds or datestring).",
+        default=None,
+    )
+    order: Optional[str] = Field(
+        description="The order of the result (ASC or DESC).",
+        default=DEFAULT_ORDER,
+    )
+    transaction_types: Optional[List[str]] = Field(
+        description="Array of transaction types. Allowed values are 'buy', 'sell'.",
+        default=None,
+    )
+
+
+class WalletSwaps(PortfolioBaseTool):
+    """Tool for retrieving swap-related transactions for a wallet using Moralis.
+
+    This tool uses Moralis' API to fetch all swap-related (buy, sell) transactions
+    for a specific wallet address.
+    """
+
+    name: str = "portfolio_wallet_swaps"
+    description: str = (
+        "Get all swap-related transactions (buy, sell) for a wallet address. "
+        "Note that swaps data is only available from September 2024 onwards."
+    )
+    args_schema: Type[BaseModel] = WalletSwapsInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = DEFAULT_LIMIT,
+        from_block: Optional[str] = None,
+        to_block: Optional[str] = None,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+        order: Optional[str] = DEFAULT_ORDER,
+        transaction_types: Optional[List[str]] = None,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch wallet swap transactions from Moralis.
+
+        Args:
+            address: The wallet address to get swaps for
+            chain: The blockchain to query
+            cursor: Pagination cursor
+            limit: Number of results per page
+            from_block: Minimum block number for transactions
+            to_block: Maximum block number for transactions
+            from_date: Start date for transactions
+            to_date: End date for transactions
+            order: Order of results (ASC/DESC)
+            transaction_types: Types of transactions to include ('buy', 'sell')
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing wallet swaps data
+        """
+        context = self.context_from_config(config)
+        logger.debug(f"wallet_swaps.py: Fetching wallet swaps with context {context}")
+
+        # Get the API key from the agent's configuration
+        api_key = self.get_api_key(context)
+        if not api_key:
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {
+            "chain": chain,
+            "limit": limit,
+            "order": order,
+        }
+
+        # Add optional parameters if they exist
+        if cursor:
+            params["cursor"] = cursor
+        if from_block:
+            params["fromBlock"] = from_block
+        if to_block:
+            params["toBlock"] = to_block
+        if from_date:
+            params["fromDate"] = from_date
+        if to_date:
+            params["toDate"] = to_date
+        if transaction_types:
+            params["transactionTypes"] = transaction_types
+
+        # Call Moralis API
+        try:
+            endpoint = f"/wallets/{address}/swaps"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"wallet_swaps.py: Error fetching wallet swaps: {e}", exc_info=True
+            )
+            return {
+                "error": "An error occurred while fetching wallet swaps. Please try again later."
+            }

intentkit/skills/skills.toml

@@ -0,0 +1,103 @@
+[acolyt]
+author_github = "TxCorpi0x"
+author_wallet = "0x2Bd32A312280bF5A01140e68ca630fB76cE8A3De"
+
+[aixbt]
+author_github = "bluntbrain"
+author_wallet = "0x3cdd051eeC909f94965F9c1c657f5b70a172B2C0"
+
+[allora]
+author_github = "TxCorpi0x"
+author_wallet = "0x2Bd32A312280bF5A01140e68ca630fB76cE8A3De"
+
+[cdp]
+author_github = "hyacinthus"
+author_wallet = "0x445750026A4a1906b61302442E085f9cbAfe206a"
+
+[chainlist]
+author_github = "bluntbrain"
+author_wallet = "0x3cdd051eeC909f94965F9c1c657f5b70a172B2C0"
+
+[common]
+author_github = "hyacinthus"
+author_wallet = "0x445750026A4a1906b61302442E085f9cbAfe206a"
+
+[cryptocompare]
+author_github = "0xkieranwilliams"
+author_wallet = "0x91D43BfDc698b1e510efa0811e2e07F628D02e6b"
+
+[cryptopanic]
+author_github = "v1ktorrr0x"
+author_wallet = "0x178741Fc5BA9B77147398853c28736eEFe5fCff1"
+
+[dapplooker]
+author_github = "bluntbrain"
+author_wallet = "0x3cdd051eeC909f94965F9c1c657f5b70a172B2C0"
+
+[defillama]
+author_github = "0xkieranwilliams"
+author_wallet = "0x91D43BfDc698b1e510efa0811e2e07F628D02e6b"
+
+[elfa]
+author_github = "TxCorpi0x"
+author_wallet = "0x2Bd32A312280bF5A01140e68ca630fB76cE8A3De"
+
+[enso]
+author_github = "TxCorpi0x"
+author_wallet = "0x2Bd32A312280bF5A01140e68ca630fB76cE8A3De"
+
+[github]
+author_github = "bluntbrain"
+author_wallet = "0x3cdd051eeC909f94965F9c1c657f5b70a172B2C0"
+
+[goat]
+author_github = "TxCorpi0x"
+author_wallet = "0x2Bd32A312280bF5A01140e68ca630fB76cE8A3De"
+
+[heurist]
+author_github = "hyacinthus"
+author_wallet = "0x445750026A4a1906b61302442E085f9cbAfe206a"
+
+[moralis]
+author_github = "developerfred"
+author_wallet = "0xd1a8Dd23e356B9fAE27dF5DeF9ea025A602EC81e"
+
+[nation]
+author_github = "spidemen"
+author_wallet = "0x275960ad41DbE218bBf72cDF612F88b5C6f40648"
+
+[openai]
+author_github = "hyacinthus"
+author_wallet = "0x445750026A4a1906b61302442E085f9cbAfe206a"
+
+[slack]
+author_github = "hyacinthus"
+author_wallet = "0x445750026A4a1906b61302442E085f9cbAfe206a"
+
+[system]
+author_github = "hyacinthus"
+author_wallet = "0x445750026A4a1906b61302442E085f9cbAfe206a"
+
+[tavily]
+author_github = "bluntbrain"
+author_wallet = "0x3cdd051eeC909f94965F9c1c657f5b70a172B2C0"
+
+[twitter]
+author_github = "hyacinthus"
+author_wallet = "0x445750026A4a1906b61302442E085f9cbAfe206a"
+
+[unrealspeech]
+author_github = "bluntbrain"
+author_wallet = "0x3cdd051eeC909f94965F9c1c657f5b70a172B2C0"
+
+[venice_image]
+author_github = "yornfifty"
+author_wallet = "0xF60D4B6780D5D51827602D7aC319458bc9e921F4"
+
+[portfolio]
+author_github = "bluntbrain"
+author_wallet = "0x3cdd051eeC909f94965F9c1c657f5b70a172B2C0"
+
+[token]
+author_github = "bluntbrain"
+author_wallet = "0x3cdd051eeC909f94965F9c1c657f5b70a172B2C0"

intentkit/skills/slack/__init__.py

@@ -0,0 +1,98 @@
+"""Slack skills."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.slack.base import SlackBaseTool
+from intentkit.skills.slack.get_channel import SlackGetChannel
+from intentkit.skills.slack.get_message import SlackGetMessage
+from intentkit.skills.slack.schedule_message import SlackScheduleMessage
+from intentkit.skills.slack.send_message import SlackSendMessage
+
+# we cache skills in system level, because they are stateless
+_cache: dict[str, SlackBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    get_channel: SkillState
+    get_message: SkillState
+    schedule_message: SkillState
+    send_message: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for Slack skills."""
+
+    states: SkillStates
+    slack_bot_token: str
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[SlackBaseTool]:
+    """Get all Slack 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_slack_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_slack_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> SlackBaseTool:
+    """Get a Slack skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested Slack skill
+    """
+    if name == "get_channel":
+        if name not in _cache:
+            _cache[name] = SlackGetChannel(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "get_message":
+        if name not in _cache:
+            _cache[name] = SlackGetMessage(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "schedule_message":
+        if name not in _cache:
+            _cache[name] = SlackScheduleMessage(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "send_message":
+        if name not in _cache:
+            _cache[name] = SlackSendMessage(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown Slack skill: {name}")
+        return None

intentkit/skills/slack/base.py

@@ -0,0 +1,55 @@
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+from slack_sdk import WebClient
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+
+class SlackBaseTool(IntentKitSkill):
+    """Base class for Slack 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 "slack"
+
+    def get_client(self, token: str) -> WebClient:
+        """Get a Slack WebClient instance.
+
+        Args:
+            token: The Slack bot token to use
+
+        Returns:
+            WebClient: A configured Slack client
+        """
+        return WebClient(token=token)
+
+
+class SlackChannel(BaseModel):
+    """Model representing a Slack channel."""
+
+    id: str
+    name: str
+    is_private: bool
+    created: int
+    creator: str
+    is_archived: bool
+    members: list[str] = []
+
+
+class SlackMessage(BaseModel):
+    """Model representing a Slack message."""
+
+    ts: str
+    text: str
+    user: str
+    channel: str
+    thread_ts: Optional[str] = None

intentkit/skills/slack/get_channel.py

@@ -0,0 +1,109 @@
+from typing import Any, Dict, Optional, Type, Union
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.slack.base import SlackBaseTool, SlackChannel
+
+
+class SlackGetChannelSchema(BaseModel):
+    """Input schema for SlackGetChannel."""
+
+    channel_id: Optional[str] = Field(
+        None,
+        description="The ID of the channel to get information about. Provide either channel_id or channel_name.",
+    )
+    channel_name: Optional[str] = Field(
+        None,
+        description="The name of the channel to get information about. Provide either channel_id or channel_name.",
+    )
+
+
+class SlackGetChannel(SlackBaseTool):
+    """Tool for getting information about a Slack channel."""
+
+    name: str = "slack_get_channel"
+    description: str = "Get information about a Slack channel by ID or name"
+    args_schema: Type[BaseModel] = SlackGetChannelSchema
+
+    async def _arun(
+        self,
+        config: RunnableConfig,
+        channel_id: Optional[str] = None,
+        channel_name: Optional[str] = None,
+        **kwargs,
+    ) -> Union[SlackChannel, Dict[str, SlackChannel]]:
+        """Run the tool to get information about a Slack channel.
+
+        Args:
+            channel_id: The ID of the channel to get information about
+            channel_name: The name of the channel to get information about
+
+        Returns:
+            Information about the requested channel or all channels if no ID/name provided
+
+        Raises:
+            ValueError: If neither channel_id nor channel_name is provided
+            Exception: If an error occurs getting the channel information
+        """
+        context = self.context_from_config(config)
+        client = self.get_client(context.config.get("slack_bot_token"))
+
+        try:
+            # If no channel specified, return a dict of all channels
+            if not channel_id and not channel_name:
+                # Get all channels
+                response = client.conversations_list()
+                if response["ok"]:
+                    channels = {}
+                    for channel in response["channels"]:
+                        channels[channel["id"]] = self._format_channel(channel)
+                    return channels
+                else:
+                    raise Exception(f"Error getting channels: {response['error']}")
+
+            # First try to find by channel_id if provided
+            if channel_id:
+                response = client.conversations_info(channel=channel_id)
+                if response["ok"]:
+                    return self._format_channel(response["channel"])
+                else:
+                    raise Exception(f"Error getting channel: {response['error']}")
+
+            # Otherwise try to find by channel_name
+            if channel_name:
+                # If channel name doesn't start with #, add it
+                if not channel_name.startswith("#"):
+                    channel_name = f"#{channel_name}"
+
+                # Get all channels and filter by name
+                response = client.conversations_list()
+                if response["ok"]:
+                    for channel in response["channels"]:
+                        if channel["name"] == channel_name.lstrip("#"):
+                            return self._format_channel(channel)
+                    raise ValueError(f"Channel {channel_name} not found")
+                else:
+                    raise Exception(f"Error getting channels: {response['error']}")
+
+        except Exception as e:
+            raise Exception(f"Error getting channel information: {str(e)}")
+
+    def _format_channel(self, channel: Dict[str, Any]) -> SlackChannel:
+        """Format the channel data into a SlackChannel model.
+
+        Args:
+            channel: The raw channel data from the Slack API
+
+        Returns:
+            A formatted SlackChannel object
+        """
+        return SlackChannel(
+            id=channel["id"],
+            name=channel["name"],
+            is_private=channel.get("is_private", False),
+            created=channel.get("created", 0),
+            creator=channel.get("creator", ""),
+            is_archived=channel.get("is_archived", False),
+            members=channel.get("members", []),
+        )

intentkit/skills/slack/get_message.py

@@ -0,0 +1,136 @@
+from typing import Any, Dict, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.slack.base import SlackBaseTool, SlackMessage
+
+
+class SlackGetMessageSchema(BaseModel):
+    """Input schema for SlackGetMessage."""
+
+    channel_id: str = Field(
+        description="The ID of the channel containing the message",
+    )
+    ts: Optional[str] = Field(
+        None,
+        description="The timestamp of a specific message to retrieve. If not provided, returns recent messages.",
+    )
+    thread_ts: Optional[str] = Field(
+        None,
+        description="If provided, retrieve messages from this thread instead of the channel.",
+    )
+    limit: Optional[int] = Field(
+        10,
+        description="The maximum number of messages to return (1-100, default 10).",
+    )
+
+
+class SlackGetMessage(SlackBaseTool):
+    """Tool for getting messages from a Slack channel or thread."""
+
+    name: str = "slack_get_message"
+    description: str = "Get messages from a Slack channel or thread"
+    args_schema: Type[BaseModel] = SlackGetMessageSchema
+
+    async def _arun(
+        self,
+        config: RunnableConfig,
+        channel_id: str,
+        ts: Optional[str] = None,
+        thread_ts: Optional[str] = None,
+        limit: int = 10,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Run the tool to get Slack messages.
+
+        Args:
+            channel_id: The ID of the channel to get messages from
+            ts: The timestamp of a specific message to retrieve
+            thread_ts: If provided, retrieve messages from this thread
+            limit: Maximum number of messages to return (1-100)
+
+        Returns:
+            A dictionary containing the requested messages
+
+        Raises:
+            Exception: If an error occurs getting the messages
+        """
+        context = self.context_from_config(config)
+        client = self.get_client(context.config.get("slack_bot_token"))
+
+        try:
+            # Ensure limit is within bounds
+            if limit < 1:
+                limit = 1
+            elif limit > 100:
+                limit = 100
+
+            # Get a specific message by timestamp
+            if ts and not thread_ts:
+                response = client.conversations_history(
+                    channel=channel_id, latest=ts, limit=1, inclusive=True
+                )
+                if response["ok"] and response["messages"]:
+                    return {
+                        "messages": [
+                            self._format_message(response["messages"][0], channel_id)
+                        ]
+                    }
+                else:
+                    raise Exception(f"Message with timestamp {ts} not found")
+
+            # Get messages from a thread
+            elif thread_ts:
+                response = client.conversations_replies(
+                    channel=channel_id, ts=thread_ts, limit=limit
+                )
+                if response["ok"]:
+                    return {
+                        "messages": [
+                            self._format_message(msg, channel_id)
+                            for msg in response["messages"]
+                        ],
+                        "has_more": response.get("has_more", False),
+                    }
+                else:
+                    raise Exception(
+                        f"Error getting thread messages: {response.get('error')}"
+                    )
+
+            # Get channel history
+            else:
+                response = client.conversations_history(channel=channel_id, limit=limit)
+                if response["ok"]:
+                    return {
+                        "messages": [
+                            self._format_message(msg, channel_id)
+                            for msg in response["messages"]
+                        ],
+                        "has_more": response.get("has_more", False),
+                    }
+                else:
+                    raise Exception(
+                        f"Error getting channel messages: {response.get('error')}"
+                    )
+
+        except Exception as e:
+            raise Exception(f"Error getting messages: {str(e)}")
+
+    def _format_message(self, message: Dict[str, Any], channel_id: str) -> SlackMessage:
+        """Format the message data into a SlackMessage model.
+
+        Args:
+            message: The raw message data from the Slack API
+            channel_id: The channel ID the message belongs to
+
+        Returns:
+            A formatted SlackMessage object
+        """
+        return SlackMessage(
+            ts=message["ts"],
+            text=message["text"],
+            user=message.get("user", ""),
+            channel=channel_id,
+            thread_ts=message.get("thread_ts"),
+        )