intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__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.6.13-dev2"
+__version__ = "0.8.17"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

intentkit/abstracts/agent.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from typing import Dict, Optional
 
 from intentkit.models.agent import Agent
 from intentkit.models.agent_data import AgentData, AgentQuota
@@ -24,7 +23,7 @@ class AgentStoreABC(ABC):
         self.agent_id = agent_id
 
     @abstractmethod
-    async def get_config(self) -> Optional[Agent]:
+    async def get_config(self) -> Agent | None:
         """Get agent configuration.
 
         Returns:
@@ -33,7 +32,7 @@ class AgentStoreABC(ABC):
         pass
 
     @abstractmethod
-    async def get_data(self) -> Optional[AgentData]:
+    async def get_data(self) -> AgentData | None:
         """Get additional agent data.
 
         Returns:
@@ -42,7 +41,7 @@ class AgentStoreABC(ABC):
         pass
 
     @abstractmethod
-    async def set_data(self, data: Dict) -> None:
+    async def set_data(self, data: dict) -> None:
         """Update agent data.
 
         Args:
@@ -51,7 +50,7 @@ class AgentStoreABC(ABC):
         pass
 
     @abstractmethod
-    async def get_quota(self) -> Optional[AgentQuota]:
+    async def get_quota(self) -> AgentQuota | None:
         """Get agent quota information.
 
         Returns:

intentkit/abstracts/engine.py

@@ -1,4 +1,4 @@
-from typing import Callable, List
+from collections.abc import Callable
 
 from pydantic import BaseModel
 
@@ -12,19 +12,19 @@ class AgentMessageInput(BaseModel):
 
     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.
+        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
+    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]]
+AgentExecutionCallback = Callable[[str, AgentMessageInput, str], list[str]]
 """Callback function type for agent execution.
 
 Args:
@@ -33,6 +33,6 @@ Args:
     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
+    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/abstracts/graph.py

@@ -1,6 +1,6 @@
-import asyncio
+from collections.abc import Callable
 from enum import Enum
-from typing import Any, Dict, NotRequired, Optional
+from typing import Any, NotRequired
 
 from langgraph.prebuilt.chat_agent_executor import AgentState as BaseAgentState
 from pydantic import BaseModel
@@ -24,18 +24,25 @@ class AgentState(BaseAgentState):
 
     context: dict[str, Any]
     error: NotRequired[AgentError]
-    __extra__: NotRequired[Dict[str, Any]]
+    __extra__: NotRequired[dict[str, Any]]
 
 
 class AgentContext(BaseModel):
     agent_id: str
+    get_agent: Callable[[], Agent]
     chat_id: str
-    user_id: Optional[str] = None
-    app_id: Optional[str] = None
+    user_id: str | None = None
+    app_id: str | None = None
     entrypoint: AuthorType
     is_private: bool
-    payer: Optional[str] = None
+    search: bool = False
+    thinking: bool = False
+    payer: str | None = None
 
     @property
     def agent(self) -> Agent:
-        return asyncio.run(Agent.get(self.agent_id))
+        return self.get_agent()
+
+    @property
+    def thread_id(self) -> str:
+        return f"{self.agent_id}-{self.chat_id}"

intentkit/abstracts/skill.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
+from typing import Any
 
-from intentkit.models.agent import Agent, AgentAutonomous
+from intentkit.models.agent import Agent
 from intentkit.models.agent_data import AgentData, AgentQuota
 
 
@@ -20,7 +20,7 @@ class SkillStoreABC(ABC):
 
     @staticmethod
     @abstractmethod
-    async def get_agent_config(agent_id: str) -> Optional[Agent]:
+    async def get_agent_config(agent_id: str) -> Agent | None:
         """Get agent configuration.
 
         Returns:
@@ -30,7 +30,7 @@ class SkillStoreABC(ABC):
 
     @staticmethod
     @abstractmethod
-    async def get_agent_data(agent_id: str) -> Optional[AgentData]:
+    async def get_agent_data(agent_id: str) -> AgentData | None:
         """Get additional agent data.
 
         Returns:
@@ -40,7 +40,7 @@ class SkillStoreABC(ABC):
 
     @staticmethod
     @abstractmethod
-    async def set_agent_data(agent_id: str, data: Dict) -> None:
+    async def set_agent_data(agent_id: str, data: dict) -> None:
         """Update agent data.
 
         Args:
@@ -51,148 +51,10 @@ class SkillStoreABC(ABC):
 
     @staticmethod
     @abstractmethod
-    async def get_agent_quota(agent_id: str) -> Optional[AgentQuota]:
+    async def get_agent_quota(agent_id: str) -> AgentQuota | None:
         """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 delete_agent_skill_data(agent_id: str, skill: str, key: str) -> None:
-        """Delete skill data for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            skill: Name of the skill
-            key: Data key
-        """
-        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
-
-    @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/abstracts/twitter.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from typing import Optional
 
 from tweepy.asynchronous import AsyncClient
 
@@ -15,7 +14,7 @@ class TwitterABC(ABC):
     use_key = False
 
     @abstractmethod
-    async def get_client(self) -> Optional[AsyncClient]:
+    async def get_client(self) -> AsyncClient | None:
         """Get a configured Tweepy client.
 
         Returns:
@@ -25,7 +24,7 @@ class TwitterABC(ABC):
 
     @property
     @abstractmethod
-    def self_id(self) -> Optional[str]:
+    def self_id(self) -> str | None:
         """Get the Twitter user ID.
 
         Returns:
@@ -35,7 +34,7 @@ class TwitterABC(ABC):
 
     @property
     @abstractmethod
-    def self_username(self) -> Optional[str]:
+    def self_username(self) -> str | None:
         """Get the Twitter username.
 
         Returns:
@@ -45,7 +44,7 @@ class TwitterABC(ABC):
 
     @property
     @abstractmethod
-    def self_name(self) -> Optional[str]:
+    def self_name(self) -> str | None:
         """Get the Twitter display name.
 
         Returns:

intentkit/clients/__init__.py

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

intentkit/clients/cdp.py

@@ -1,168 +1,128 @@
-import json
+import asyncio
 import logging
-from typing import Dict, Optional
-
-from bip32 import BIP32
-from cdp import CdpClient as OriginCdpClient
-from cdp import EvmServerAccount
-from coinbase_agentkit import (
-    CdpEvmServerWalletProvider,
-    CdpEvmServerWalletProviderConfig,
+
+from cdp import CdpClient, EvmServerAccount  # noqa: E402
+from coinbase_agentkit import (  # noqa: E402
+    CdpEvmWalletProvider,
+    CdpEvmWalletProviderConfig,
 )
-from eth_keys.datatypes import PrivateKey
-from eth_utils import to_checksum_address
 
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.models.agent import Agent
+from intentkit.config.config import config
+from intentkit.models.agent import Agent, AgentTable  # noqa: E402
 from intentkit.models.agent_data import AgentData
+from intentkit.models.db import get_session
+from intentkit.utils.error import IntentKitAPIError  # noqa: E402
 
-_clients: Dict[str, "CdpClient"] = {}
-_origin_cdp_client: Optional[OriginCdpClient] = None
+_wallet_providers: dict[str, tuple[str, str, CdpEvmWalletProvider]] = {}
+_cdp_client: CdpClient | None = None
 
 logger = logging.getLogger(__name__)
 
 
-def bip39_seed_to_eth_keys(seed_hex: str) -> Dict[str, str]:
-    """
-    Converts a BIP39 seed to an Ethereum private key, public key, and address.
+def get_cdp_client() -> CdpClient:
+    global _cdp_client
+    if _cdp_client:
+        return _cdp_client
 
-    Args:
-        seed_hex: The BIP39 seed in hexadecimal format
+    # 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
 
-    Returns:
-        Dict containing private_key, public_key, and address
-    """
-    # Convert the hex seed to bytes
-    seed_bytes = bytes.fromhex(seed_hex)
+    _cdp_client = CdpClient(
+        api_key_id=api_key_id,
+        api_key_secret=api_key_secret,
+        wallet_secret=wallet_secret,
+    )
+    return _cdp_client
 
-    # Derive the master key from the seed
-    bip32 = BIP32.from_seed(seed_bytes)
 
-    # Derive the Ethereum address using the standard derivation path
-    private_key_bytes = bip32.get_privkey_from_path("m/44'/60'/0'/0/0")
+def _assert_cdp_wallet_provider(agent: Agent) -> None:
+    if agent.wallet_provider != "cdp":
+        raise IntentKitAPIError(
+            400,
+            "BadWalletProvider",
+            "Your agent wallet provider is not cdp but you selected a skill that requires a cdp wallet.",
+        )
 
-    # Create a private key object
-    private_key = PrivateKey(private_key_bytes)
 
-    # Get the public key
-    public_key = private_key.public_key
+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: EvmServerAccount | None = None
 
-    # Get the Ethereum address
-    address = public_key.to_address()
+    if not address:
+        logger.info("Creating new wallet...")
+        account = await cdp_client.evm.create_account(
+            name=agent.id,
+        )
+        address = account.address
+        logger.info("Created new wallet: %s", address)
 
-    return {
-        "private_key": private_key.to_hex(),
-        "public_key": public_key.to_hex(),
-        "address": to_checksum_address(address),
-    }
+    agent_data.evm_wallet_address = address
+    await agent_data.save()
+    if not agent.slug:
+        async with get_session() as db:
+            db_agent = await db.get(AgentTable, agent.id)
+            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)
 
-def get_origin_cdp_client(skill_store: SkillStoreABC) -> OriginCdpClient:
-    global _origin_cdp_client
-    if _origin_cdp_client:
-        return _origin_cdp_client
+    return account, agent_data
 
-    # Get credentials from skill store system config
-    api_key_id = skill_store.get_system_config("cdp_api_key_id")
-    api_key_secret = skill_store.get_system_config("cdp_api_key_secret")
-    wallet_secret = skill_store.get_system_config("cdp_wallet_secret")
 
-    _origin_cdp_client = OriginCdpClient(
-        api_key_id=api_key_id,
-        api_key_secret=api_key_secret,
-        wallet_secret=wallet_secret,
-    )
-    return _origin_cdp_client
-
-
-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[CdpEvmServerWalletProvider] = None
-        self._wallet_provider_config: Optional[CdpEvmServerWalletProviderConfig] = None
-
-    async def get_wallet_provider(self) -> CdpEvmServerWalletProvider:
-        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
-
-        # Get credentials from skill store system config
-        api_key_id = self._skill_store.get_system_config("cdp_api_key_id")
-        api_key_secret = self._skill_store.get_system_config("cdp_api_key_secret")
-        wallet_secret = self._skill_store.get_system_config("cdp_wallet_secret")
-
-        # already have address
-        address = agent_data.evm_wallet_address
-
-        # new agent or address not migrated yet
-        if not address:
-            # create cdp client for later use
-            cdp_client = get_origin_cdp_client(self._skill_store)
-            # 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(
-                        name=agent.id,
-                        private_key=keys["private_key"],
-                    )
-                    address = keys["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(
-                    name=agent.id,
-                )
-                address = new_account.address
-                logger.info("Created new wallet: %s", address)
-
-            # do not close cached global client
-            # now it should be created or migrated, store it
-            agent_data.evm_wallet_address = address
-            await agent_data.save()
-
-        # it must have v2 account now, load agentkit wallet provider
-        self._wallet_provider_config = CdpEvmServerWalletProviderConfig(
-            api_key_id=api_key_id,
-            api_key_secret=api_key_secret,
-            network_id=network_id,
-            address=address,
-            wallet_secret=wallet_secret,
+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.",
         )
-        self._wallet_provider = CdpEvmServerWalletProvider(self._wallet_provider_config)
-        return self._wallet_provider
 
-    async def get_account(self) -> EvmServerAccount:
-        """Get the account object from the wallet provider.
+    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
 
-        Returns:
-            EvmServerAccount: The account object that can be used for balance checks, transfers, etc.
-        """
-        wallet_provider = await self.get_wallet_provider()
-        # Access the internal account object
-        return wallet_provider._account
+    account, agent_data = await _ensure_evm_account(agent, agent_data)
+    address = account.address
 
-    async def get_provider_config(self) -> CdpEvmServerWalletProviderConfig:
-        if not self._wallet_provider_config:
-            await self.get_wallet_provider()
-        return self._wallet_provider_config
+    # 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
 
-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]
+    wallet_provider_config = CdpEvmWalletProviderConfig(
+        api_key_id=api_key_id,
+        api_key_secret=api_key_secret,
+        network_id=network_id,
+        address=address,
+        wallet_secret=wallet_secret,
+    )
+    wallet_provider = await asyncio.to_thread(
+        CdpEvmWalletProvider, wallet_provider_config
+    )
+    _wallet_providers[agent.id] = (network_id, address, wallet_provider)
+    return wallet_provider