intentkit 0.8.12rc0__py3-none-any.whl → 0.8.13__py3-none-any.whl

intentkit/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.8.12-rc.0"
+__version__ = "0.8.13"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

intentkit/abstracts/skill.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
-from intentkit.models.agent import Agent, AgentAutonomous
+from intentkit.models.agent import Agent
 from intentkit.models.agent_data import AgentData, AgentQuota
 
 
@@ -58,60 +58,3 @@ class SkillStoreABC(ABC):
             Agent quota if found, None otherwise
         """
         pass
-
-    @staticmethod
-    @abstractmethod
-    async def list_autonomous_tasks(agent_id: str) -> List[AgentAutonomous]:
-        """List all autonomous tasks for an agent.
-
-        Args:
-            agent_id: ID of the agent
-
-        Returns:
-            List[AgentAutonomous]: List of autonomous task configurations
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    async def add_autonomous_task(
-        agent_id: str, task: AgentAutonomous
-    ) -> AgentAutonomous:
-        """Add a new autonomous task to an agent.
-
-        Args:
-            agent_id: ID of the agent
-            task: Autonomous task configuration
-
-        Returns:
-            AgentAutonomous: The created task
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    async def delete_autonomous_task(agent_id: str, task_id: str) -> None:
-        """Delete an autonomous task from an agent.
-
-        Args:
-            agent_id: ID of the agent
-            task_id: ID of the task to delete
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    async def update_autonomous_task(
-        agent_id: str, task_id: str, task_updates: dict
-    ) -> AgentAutonomous:
-        """Update an autonomous task for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            task_id: ID of the task to update
-            task_updates: Dictionary containing fields to update
-
-        Returns:
-            AgentAutonomous: The updated task
-        """
-        pass

intentkit/clients/__init__.py

@@ -1,4 +1,4 @@
-from intentkit.clients.cdp import get_origin_cdp_client, get_wallet_provider
+from intentkit.clients.cdp import get_cdp_client, get_evm_account, get_wallet_provider
 from intentkit.clients.twitter import (
     TwitterClient,
     TwitterClientConfig,
@@ -10,7 +10,8 @@ __all__ = [
     "TwitterClient",
     "TwitterClientConfig",
     "get_twitter_client",
-    "get_origin_cdp_client",
+    "get_evm_account",
+    "get_cdp_client",
     "get_wallet_provider",
     "get_web3_client",
 ]

intentkit/clients/cdp.py

@@ -4,7 +4,7 @@ import logging
 from typing import Dict, Optional, Tuple
 
 from bip32 import BIP32
-from cdp import CdpClient as OriginCdpClient  # noqa: E402
+from cdp import CdpClient, EvmServerAccount  # noqa: E402
 from coinbase_agentkit import (  # noqa: E402
     CdpEvmWalletProvider,
     CdpEvmWalletProviderConfig,
@@ -19,7 +19,7 @@ from intentkit.models.db import get_session
 from intentkit.utils.error import IntentKitAPIError  # noqa: E402
 
 _wallet_providers: Dict[str, Tuple[str, str, CdpEvmWalletProvider]] = {}
-_origin_cdp_client: Optional[OriginCdpClient] = None
+_cdp_client: Optional[CdpClient] = None
 
 logger = logging.getLogger(__name__)
 
@@ -59,25 +59,25 @@ def bip39_seed_to_eth_keys(seed_hex: str) -> Dict[str, str]:
     }
 
 
-def get_origin_cdp_client() -> OriginCdpClient:
-    global _origin_cdp_client
-    if _origin_cdp_client:
-        return _origin_cdp_client
+def get_cdp_client() -> CdpClient:
+    global _cdp_client
+    if _cdp_client:
+        return _cdp_client
 
     # Get credentials from global configuration
     api_key_id = config.cdp_api_key_id
     api_key_secret = config.cdp_api_key_secret
     wallet_secret = config.cdp_wallet_secret
 
-    _origin_cdp_client = OriginCdpClient(
+    _cdp_client = CdpClient(
         api_key_id=api_key_id,
         api_key_secret=api_key_secret,
         wallet_secret=wallet_secret,
     )
-    return _origin_cdp_client
+    return _cdp_client
 
 
-async def get_wallet_provider(agent: Agent) -> CdpEvmWalletProvider:
+def _assert_cdp_wallet_provider(agent: Agent) -> None:
     if agent.wallet_provider != "cdp":
         raise IntentKitAPIError(
             400,
@@ -85,74 +85,93 @@ async def get_wallet_provider(agent: Agent) -> CdpEvmWalletProvider:
             "Your agent wallet provider is not cdp but you selected a skill that requires a cdp wallet.",
         )
 
-    if not agent.network_id:
-        raise IntentKitAPIError(
-            400,
-            "BadNetworkID",
-            "Your agent network ID is not set. Please set it in the agent config.",
-        )
 
-    agent_data = await AgentData.get(agent.id)
+async def _ensure_evm_account(
+    agent: Agent, agent_data: AgentData | None = None
+) -> Tuple[EvmServerAccount, AgentData]:
+    cdp_client = get_cdp_client()
+    agent_data = agent_data or await AgentData.get(agent.id)
     address = agent_data.evm_wallet_address
+    account: Optional[EvmServerAccount] = None
 
-    cache_entry = _wallet_providers.get(agent.id)
-    if cache_entry:
-        cached_network_id, cached_address, provider = cache_entry
-        if cached_network_id == agent.network_id:
-            if not address:
-                address = cached_address or provider.get_address()
-            if cached_address == address:
-                return provider
-
-    # Get credentials from global config
-    api_key_id = config.cdp_api_key_id
-    api_key_secret = config.cdp_api_key_secret
-    wallet_secret = config.cdp_wallet_secret
-
-    network_id = agent.network_id
-
-    # new agent or address not migrated yet
     if not address:
-        cdp_client = get_origin_cdp_client()
-        # try migrating from v1 cdp_wallet_data
         if agent_data.cdp_wallet_data:
             wallet_data = json.loads(agent_data.cdp_wallet_data)
             if not isinstance(wallet_data, dict):
                 raise ValueError("Invalid wallet data format")
             if wallet_data.get("default_address_id") and wallet_data.get("seed"):
-                # verify seed and convert to pk
                 keys = bip39_seed_to_eth_keys(wallet_data["seed"])
                 if keys["address"] != wallet_data["default_address_id"]:
                     raise ValueError(
                         "Bad wallet data, seed does not match default_address_id"
                     )
-                # try to import wallet to v2
                 logger.info("Migrating wallet data to v2...")
-                await cdp_client.evm.import_account(
+                account = await cdp_client.evm.import_account(
                     name=agent.id,
                     private_key=keys["private_key"],
                 )
-                address = keys["address"]
+                address = account.address
                 logger.info("Migrated wallet data to v2 successfully: %s", address)
-        # still not address
         if not address:
             logger.info("Creating new wallet...")
-            new_account = await cdp_client.evm.create_account(
+            account = await cdp_client.evm.create_account(
                 name=agent.id,
             )
-            address = new_account.address
+            address = account.address
             logger.info("Created new wallet: %s", address)
 
         agent_data.evm_wallet_address = address
         await agent_data.save()
-        # Update agent slug with evm_wallet_address if slug is null or empty
         if not agent.slug:
             async with get_session() as db:
                 db_agent = await db.get(AgentTable, agent.id)
-                if db_agent:
+                if db_agent and not db_agent.slug:
                     db_agent.slug = agent_data.evm_wallet_address
                     await db.commit()
 
+    if account is None:
+        account = await cdp_client.evm.get_account(address=address)
+
+    return account, agent_data
+
+
+async def get_evm_account(agent: Agent) -> EvmServerAccount:
+    _assert_cdp_wallet_provider(agent)
+    account, _ = await _ensure_evm_account(agent)
+    return account
+
+
+async def get_wallet_provider(agent: Agent) -> CdpEvmWalletProvider:
+    _assert_cdp_wallet_provider(agent)
+    if not agent.network_id:
+        raise IntentKitAPIError(
+            400,
+            "BadNetworkID",
+            "Your agent network ID is not set. Please set it in the agent config.",
+        )
+
+    agent_data = await AgentData.get(agent.id)
+    address = agent_data.evm_wallet_address
+
+    cache_entry = _wallet_providers.get(agent.id)
+    if cache_entry:
+        cached_network_id, cached_address, provider = cache_entry
+        if cached_network_id == agent.network_id:
+            if not address:
+                address = cached_address or provider.get_address()
+            if cached_address == address:
+                return provider
+
+    account, agent_data = await _ensure_evm_account(agent, agent_data)
+    address = account.address
+
+    # Get credentials from global config
+    api_key_id = config.cdp_api_key_id
+    api_key_secret = config.cdp_api_key_secret
+    wallet_secret = config.cdp_wallet_secret
+
+    network_id = agent.network_id
+
     wallet_provider_config = CdpEvmWalletProviderConfig(
         api_key_id=api_key_id,
         api_key_secret=api_key_secret,

intentkit/clients/twitter.py

@@ -11,7 +11,6 @@ from requests.auth import HTTPBasicAuth
 from requests_oauthlib import OAuth2Session
 from tweepy.asynchronous import AsyncClient
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.abstracts.twitter import TwitterABC
 from intentkit.models.agent_data import AgentData
 from intentkit.models.redis import get_redis
@@ -80,33 +79,44 @@ class TwitterClient(TwitterABC):
 
     Args:
         agent_id: The ID of the agent
-        skill_store: The skill store for retrieving data
         config: Configuration dictionary that may contain API keys
     """
 
-    def __init__(self, agent_id: str, skill_store: SkillStoreABC, config: Dict) -> None:
+    def __init__(self, agent_id: str, config: Dict) -> None:
         """Initialize the Twitter client.
 
         Args:
             agent_id: The ID of the agent
-            skill_store: The skill store for retrieving data
             config: Configuration dictionary that may contain API keys
         """
         self.agent_id = agent_id
         self._client: Optional[AsyncClient] = None
-        self._skill_store = skill_store
         self._agent_data: Optional[AgentData] = None
         self.use_key = _is_self_key(config)
         self._config = config
 
+    async def _get_agent_data(self) -> AgentData:
+        """Retrieve cached agent data, loading from the database if needed."""
+
+        if not self._agent_data:
+            self._agent_data = await AgentData.get(self.agent_id)
+        return self._agent_data
+
+    async def _refresh_agent_data(self) -> AgentData:
+        """Reload agent data from the database."""
+
+        self._agent_data = await AgentData.get(self.agent_id)
+        return self._agent_data
+
     async def get_client(self) -> AsyncClient:
         """Get the initialized Twitter client.
 
         Returns:
             AsyncClient: The Twitter client if initialized
         """
-        if not self._agent_data:
-            self._agent_data = await self._skill_store.get_agent_data(self.agent_id)
+
+        agent_data = await self._get_agent_data()
+
         if not self._client:
             # Check if we have API keys in config
             if self.use_key:
@@ -118,8 +128,8 @@ class TwitterClient(TwitterABC):
                     return_type=dict,
                 )
                 # refresh userinfo if needed
-                if not self._agent_data.twitter_self_key_refreshed_at or (
-                    self._agent_data.twitter_self_key_refreshed_at
+                if not agent_data.twitter_self_key_refreshed_at or (
+                    agent_data.twitter_self_key_refreshed_at
                     < datetime.now(tz=timezone.utc) - timedelta(days=1)
                 ):
                     me = await self._client.get_me(
@@ -127,7 +137,7 @@ class TwitterClient(TwitterABC):
                         user_fields="id,username,name,verified",
                     )
                     if me and "data" in me and "id" in me["data"]:
-                        await self._skill_store.set_agent_data(
+                        await AgentData.patch(
                             self.agent_id,
                             {
                                 "twitter_id": me["data"]["id"],
@@ -139,9 +149,7 @@ class TwitterClient(TwitterABC):
                                 ),
                             },
                         )
-                    self._agent_data = await self._skill_store.get_agent_data(
-                        self.agent_id
-                    )
+                    agent_data = await self._refresh_agent_data()
                 logger.info(
                     f"Twitter self key client initialized. "
                     f"Use API key: {self.use_key}, "
@@ -152,39 +160,40 @@ class TwitterClient(TwitterABC):
                 )
                 return self._client
             # Otherwise try to get OAuth2 tokens from agent data
-            if not self._agent_data.twitter_access_token:
+            if not agent_data.twitter_access_token:
                 raise Exception(f"[{self.agent_id}] Twitter access token not found")
-            if not self._agent_data.twitter_access_token_expires_at:
+            if not agent_data.twitter_access_token_expires_at:
                 raise Exception(
                     f"[{self.agent_id}] Twitter access token expiration not found"
                 )
-            if self._agent_data.twitter_access_token_expires_at <= datetime.now(
+            if agent_data.twitter_access_token_expires_at <= datetime.now(
                 tz=timezone.utc
             ):
                 raise Exception(f"[{self.agent_id}] Twitter access token has expired")
             self._client = AsyncClient(
-                bearer_token=self._agent_data.twitter_access_token,
+                bearer_token=agent_data.twitter_access_token,
                 return_type=dict,
             )
             return self._client
+
         if not self.use_key:
             # check if access token has expired
-            if self._agent_data.twitter_access_token_expires_at <= datetime.now(
+            if agent_data.twitter_access_token_expires_at <= datetime.now(
                 tz=timezone.utc
             ):
-                self._agent_data = await self._skill_store.get_agent_data(self.agent_id)
-                # check again
-                if self._agent_data.twitter_access_token_expires_at <= datetime.now(
+                agent_data = await self._refresh_agent_data()
+                if agent_data.twitter_access_token_expires_at <= datetime.now(
                     tz=timezone.utc
                 ):
                     raise Exception(
                         f"[{self.agent_id}] Twitter access token has expired"
                     )
                 self._client = AsyncClient(
-                    bearer_token=self._agent_data.twitter_access_token,
+                    bearer_token=agent_data.twitter_access_token,
                     return_type=dict,
                 )
                 return self._client
+
         return self._client
 
     @property
@@ -352,7 +361,7 @@ class TwitterClient(TwitterABC):
             ValueError: If there's an error uploading the media.
         """
         # Get agent data to access the token
-        agent_data = await self._skill_store.get_agent_data(agent_id)
+        agent_data = await AgentData.get(agent_id)
         if not agent_data.twitter_access_token:
             raise ValueError("Only linked X account can post media")
 
@@ -423,15 +432,13 @@ def _is_self_key(config: Dict) -> bool:
     return config.get("api_key_provider") == "agent_owner"
 
 
-def get_twitter_client(
-    agent_id: str, skill_store: SkillStoreABC, config: Dict
-) -> "TwitterClient":
+def get_twitter_client(agent_id: str, config: Dict) -> "TwitterClient":
     if _is_self_key(config):
         if agent_id not in _clients_self_key:
-            _clients_self_key[agent_id] = TwitterClient(agent_id, skill_store, config)
+            _clients_self_key[agent_id] = TwitterClient(agent_id, config)
         return _clients_self_key[agent_id]
     if agent_id not in _clients_linked:
-        _clients_linked[agent_id] = TwitterClient(agent_id, skill_store, config)
+        _clients_linked[agent_id] = TwitterClient(agent_id, config)
     return _clients_linked[agent_id]
 
 

intentkit/config/config.py

@@ -79,6 +79,7 @@ class Config:
         self.debug_password = self.load("DEBUG_PASSWORD")
         # Payment
         self.payment_enabled = self.load("PAYMENT_ENABLED", "false") == "true"
+        self.x402_fee_address = self.load("X402_FEE_ADDRESS")
         # Open API for agent
         self.open_api_base_url = self.load("OPEN_API_BASE_URL", "http://localhost:8000")
         # CDP - AgentKit 0.7.x Configuration