intentkit 0.5.0__tar.gz → 0.5.1__tar.gz

intentkit-0.5.1/MANIFEST.in

@@ -0,0 +1,15 @@
+include README.md
+include LICENSE
+include pyproject.toml
+recursive-include abstracts *.py
+recursive-include clients *.py
+recursive-include config *.py
+recursive-include core *.py
+recursive-include models *.py *.json
+recursive-include skills *.py *.toml *.md
+recursive-include utils *.py
+recursive-exclude * __pycache__
+recursive-exclude * *.pyc
+recursive-exclude * *.pyo
+recursive-exclude * .DS_Store
+recursive-exclude * .ruff_cache

{intentkit-0.5.0 → intentkit-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.5.0
+Version: 0.5.1
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestal-network/intentkit
 Project-URL: Repository, https://github.com/crestal-network/intentkit

intentkit-0.5.1/__init__.py

@@ -0,0 +1,17 @@
+"""IntentKit - Intent-based AI Agent Platform.
+
+A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
+"""
+
+__version__ = "0.5.1"
+__author__ = "hyacinthus"
+__email__ = "hyacinthus@gmail.com"
+
+# Core components
+# Abstract base classes
+from .core.engine import create_agent, stream_agent
+
+__all__ = [
+    "create_agent",
+    "stream_agent",
+]

intentkit-0.5.1/abstracts/agent.py

@@ -0,0 +1,60 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Optional
+
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData, AgentQuota
+
+
+class AgentStoreABC(ABC):
+    """Abstract base class for agent data storage operations.
+
+    This class defines the interface for interacting with agent-related data,
+    including configuration, additional data, and quotas.
+
+    Attributes:
+        agent_id: ID of the agent to store/retrieve data for
+    """
+
+    def __init__(self, agent_id: str) -> None:
+        """Initialize the agent store.
+
+        Args:
+            agent_id: ID of the agent
+        """
+        self.agent_id = agent_id
+
+    @abstractmethod
+    async def get_config(self) -> Optional[Agent]:
+        """Get agent configuration.
+
+        Returns:
+            Agent configuration if found, None otherwise
+        """
+        pass
+
+    @abstractmethod
+    async def get_data(self) -> Optional[AgentData]:
+        """Get additional agent data.
+
+        Returns:
+            Agent data if found, None otherwise
+        """
+        pass
+
+    @abstractmethod
+    async def set_data(self, data: Dict) -> None:
+        """Update agent data.
+
+        Args:
+            data: Dictionary containing fields to update
+        """
+        pass
+
+    @abstractmethod
+    async def get_quota(self) -> Optional[AgentQuota]:
+        """Get agent quota information.
+
+        Returns:
+            Agent quota if found, None otherwise
+        """
+        pass

intentkit-0.5.1/abstracts/api.py

@@ -0,0 +1,4 @@
+ResponseHeadersPagination = {
+    "X-Next-Cursor": {"description": "Cursor for next page"},
+    "X-Has-More": {"description": "Indicates if there are more items"},
+}

intentkit-0.5.1/abstracts/engine.py

@@ -0,0 +1,38 @@
+from typing import Callable, List
+
+from pydantic import BaseModel
+
+
+class AgentMessageInput(BaseModel):
+    """Input message model for AI agent interactions.
+
+    This class represents the structured input that can be sent to an AI agent,
+    supporting both text-based queries and image-based inputs for multimodal
+    interactions.
+
+    Attributes:
+        text (str): The main text content of the message or query
+        images (List[str]): List of image references/URLs to be processed by the agent.
+                           Empty list if no images are provided.
+    """
+
+    text: str  # required
+    """The main text content or query to be processed by the agent"""
+
+    images: List[str] = []  # optional, defaults to empty list
+    """List of image references or URLs for multimodal processing"""
+
+
+# Define a type hint for the callback that takes three strings and returns a list of strings
+AgentExecutionCallback = Callable[[str, AgentMessageInput, str], List[str]]
+"""Callback function type for agent execution.
+
+Args:
+    aid (str): The agent ID that uniquely identifies the AI agent
+    message (AgentMessageInput): The input message containing text and optional images
+    thread_id (str): The thread ID for tracking the conversation context
+
+Returns:
+    List[str]: A list of formatted response lines from the agent execution. Each line
+        typically contains input/output markers, agent responses, and timing information.
+"""

intentkit-0.5.1/abstracts/exception.py

@@ -0,0 +1,9 @@
+from typing import Optional
+
+
+class RateLimitExceeded(Exception):
+    """Rate limit exceeded"""
+
+    def __init__(self, message: Optional[str] = "Rate limit exceeded"):
+        self.message = message
+        super().__init__(self.message)

intentkit-0.5.1/abstracts/graph.py

@@ -0,0 +1,25 @@
+from enum import Enum
+from typing import Any, Callable, Dict, NotRequired
+
+from langgraph.prebuilt.chat_agent_executor import AgentState as BaseAgentState
+
+
+class AgentError(str, Enum):
+    """The error types that can be raised by the agent."""
+
+    INSUFFICIENT_CREDITS = "insufficient_credits"
+
+
+# We create the AgentState that we will pass around
+# This simply involves a list of messages
+# We want steps to return messages to append to the list
+# So we annotate the messages attribute with operator.add
+class AgentState(BaseAgentState):
+    """The state of the agent."""
+
+    context: dict[str, Any]
+    error: NotRequired[AgentError]
+    __extra__: NotRequired[Dict[str, Any]]
+
+
+MemoryManager = Callable[[AgentState], AgentState]

intentkit-0.5.1/abstracts/skill.py

@@ -0,0 +1,129 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData, AgentQuota
+
+
+class SkillStoreABC(ABC):
+    """Abstract base class for skill data storage operations.
+
+    This class defines the interface for interacting with skill-related data
+    for both agents and threads.
+    """
+
+    @staticmethod
+    @abstractmethod
+    def get_system_config(key: str) -> Any:
+        """Get system configuration value by key."""
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def get_agent_config(agent_id: str) -> Optional[Agent]:
+        """Get agent configuration.
+
+        Returns:
+            Agent configuration if found, None otherwise
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def get_agent_data(agent_id: str) -> Optional[AgentData]:
+        """Get additional agent data.
+
+        Returns:
+            Agent data if found, None otherwise
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def set_agent_data(agent_id: str, data: Dict) -> None:
+        """Update agent data.
+
+        Args:
+            agent_id: ID of the agent
+            data: Dictionary containing fields to update
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def get_agent_quota(agent_id: str) -> Optional[AgentQuota]:
+        """Get agent quota information.
+
+        Returns:
+            Agent quota if found, None otherwise
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def get_agent_skill_data(
+        agent_id: str, skill: str, key: str
+    ) -> Optional[Dict[str, Any]]:
+        """Get skill data for an agent.
+
+        Args:
+            agent_id: ID of the agent
+            skill: Name of the skill
+            key: Data key
+
+        Returns:
+            Dictionary containing the skill data if found, None otherwise
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def save_agent_skill_data(
+        agent_id: str, skill: str, key: str, data: Dict[str, Any]
+    ) -> None:
+        """Save or update skill data for an agent.
+
+        Args:
+            agent_id: ID of the agent
+            skill: Name of the skill
+            key: Data key
+            data: JSON data to store
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def get_thread_skill_data(
+        thread_id: str, skill: str, key: str
+    ) -> Optional[Dict[str, Any]]:
+        """Get skill data for a thread.
+
+        Args:
+            thread_id: ID of the thread
+            skill: Name of the skill
+            key: Data key
+
+        Returns:
+            Dictionary containing the skill data if found, None otherwise
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def save_thread_skill_data(
+        thread_id: str,
+        agent_id: str,
+        skill: str,
+        key: str,
+        data: Dict[str, Any],
+    ) -> None:
+        """Save or update skill data for a thread.
+
+        Args:
+            thread_id: ID of the thread
+            agent_id: ID of the agent that owns this thread
+            skill: Name of the skill
+            key: Data key
+            data: JSON data to store
+        """
+        pass

intentkit-0.5.1/abstracts/twitter.py

@@ -0,0 +1,54 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from tweepy.asynchronous import AsyncClient
+
+
+class TwitterABC(ABC):
+    """Abstract base class for Twitter operations.
+
+    This class defines the interface for interacting with Twitter's API
+    through a Tweepy client.
+    """
+
+    agent_id: str
+    use_key = False
+
+    @abstractmethod
+    async def get_client(self) -> Optional[AsyncClient]:
+        """Get a configured Tweepy client.
+
+        Returns:
+            A configured Tweepy client if credentials are valid, None otherwise
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def self_id(self) -> Optional[str]:
+        """Get the Twitter user ID.
+
+        Returns:
+            The Twitter user ID if available, None otherwise
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def self_username(self) -> Optional[str]:
+        """Get the Twitter username.
+
+        Returns:
+            The Twitter username (without @ symbol) if available, None otherwise
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def self_name(self) -> Optional[str]:
+        """Get the Twitter display name.
+
+        Returns:
+            The Twitter display name if available, None otherwise
+        """
+        pass

intentkit-0.5.1/clients/__init__.py

@@ -0,0 +1,14 @@
+from intentkit.clients.cdp import CdpClient, get_cdp_client
+from intentkit.clients.twitter import (
+    TwitterClient,
+    TwitterClientConfig,
+    get_twitter_client,
+)
+
+__all__ = [
+    "TwitterClient",
+    "TwitterClientConfig",
+    "get_twitter_client",
+    "CdpClient",
+    "get_cdp_client",
+]

intentkit-0.5.1/clients/cdp.py

@@ -0,0 +1,53 @@
+from typing import Dict, Optional
+
+from cdp import Wallet
+from coinbase_agentkit import (
+    CdpWalletProvider,
+    CdpWalletProviderConfig,
+)
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData
+
+_clients: Dict[str, "CdpClient"] = {}
+
+
+class CdpClient:
+    def __init__(self, agent_id: str, skill_store: SkillStoreABC) -> None:
+        self._agent_id = agent_id
+        self._skill_store = skill_store
+        self._wallet_provider: Optional[CdpWalletProvider] = None
+        self._wallet_provider_config: Optional[CdpWalletProviderConfig] = None
+
+    async def get_wallet_provider(self) -> CdpWalletProvider:
+        if self._wallet_provider:
+            return self._wallet_provider
+        agent: Agent = await self._skill_store.get_agent_config(self._agent_id)
+        agent_data: AgentData = await self._skill_store.get_agent_data(self._agent_id)
+        network_id = agent.network_id or agent.cdp_network_id
+        self._wallet_provider_config = CdpWalletProviderConfig(
+            api_key_name=self._skill_store.get_system_config("cdp_api_key_name"),
+            api_key_private_key=self._skill_store.get_system_config(
+                "cdp_api_key_private_key"
+            ),
+            network_id=network_id,
+            wallet_data=agent_data.cdp_wallet_data,
+        )
+        self._wallet_provider = CdpWalletProvider(self._wallet_provider_config)
+        return self._wallet_provider
+
+    async def get_wallet(self) -> Wallet:
+        wallet_provider = await self.get_wallet_provider()
+        return wallet_provider._wallet
+
+    async def get_provider_config(self) -> CdpWalletProviderConfig:
+        if not self._wallet_provider_config:
+            await self.get_wallet_provider()
+        return self._wallet_provider_config
+
+
+async def get_cdp_client(agent_id: str, skill_store: SkillStoreABC) -> "CdpClient":
+    if agent_id not in _clients:
+        _clients[agent_id] = CdpClient(agent_id, skill_store)
+    return _clients[agent_id]