intentkit 0.7.5.dev3__py3-none-any.whl → 0.8.34.dev7__py3-none-any.whl

intentkit/clients/cdp.py

@@ -1,179 +1,155 @@
-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
+
+    # 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
+
+    _cdp_client = CdpClient(
+        api_key_id=api_key_id,
+        api_key_secret=api_key_secret,
+        wallet_secret=wallet_secret,
+    )
+    return _cdp_client
 
-    Args:
-        seed_hex: The BIP39 seed in hexadecimal format
 
-    Returns:
-        Dict containing private_key, public_key, and address
-    """
-    # Convert the hex seed to bytes
-    seed_bytes = bytes.fromhex(seed_hex)
+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.",
+        )
+
+
+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
+
+    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)
+
+    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()
 
-    # Derive the master key from the seed
-    bip32 = BIP32.from_seed(seed_bytes)
+    if account is None:
+        account = await cdp_client.evm.get_account(address=address)
 
-    # Derive the Ethereum address using the standard derivation path
-    private_key_bytes = bip32.get_privkey_from_path("m/44'/60'/0'/0/0")
+    return account, agent_data
 
-    # Create a private key object
-    private_key = PrivateKey(private_key_bytes)
 
-    # Get the public key
-    public_key = private_key.public_key
+async def get_evm_account(agent: Agent) -> EvmServerAccount:
+    _assert_cdp_wallet_provider(agent)
+    account, _ = await _ensure_evm_account(agent)
+    return account
 
-    # Get the Ethereum address
-    address = public_key.to_address()
 
-    return {
-        "private_key": private_key.to_hex(),
-        "public_key": public_key.to_hex(),
-        "address": to_checksum_address(address),
+def get_cdp_network(agent: Agent) -> str:
+    if not agent.network_id:
+        raise IntentKitAPIError(
+            400,
+            "BadNetworkID",
+            "Your agent network ID is not set. Please set it in the agent config.",
+        )
+    mapping = {
+        "ethereum-mainnet": "ethereum",
+        "base-mainnet": "base",
+        "arbitrum-mainnet": "arbitrum",
+        "optimism-mainnet": "optimism",
+        "polygon-mainnet": "polygon",
+        "base-sepolia": "base-sepolia",
     }
+    if agent.network_id == "solana":
+        raise IntentKitAPIError(
+            400, "BadNetworkID", "Solana is not supported by CDP EVM."
+        )
+    cdp_network = mapping.get(agent.network_id)
+    if not cdp_network:
+        raise IntentKitAPIError(
+            400, "BadNetworkID", f"Unsupported network ID: {agent.network_id}"
+        )
+    return cdp_network
+
+
+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
 
-def get_origin_cdp_client(skill_store: SkillStoreABC) -> OriginCdpClient:
-    global _origin_cdp_client
-    if _origin_cdp_client:
-        return _origin_cdp_client
+    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
 
-    # 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")
+    network_id = agent.network_id
 
-    _origin_cdp_client = OriginCdpClient(
+    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,
     )
-    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
-
-        # 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,
-        )
-        self._wallet_provider = CdpEvmServerWalletProvider(self._wallet_provider_config)
-        # hack for cdp bug
-        if network_id == "base-mainnet":
-            self._wallet_provider._network.network_id = "base"
-        elif network_id == "arbitrum-mainnet":
-            self._wallet_provider._network.network_id = "arbitrum"
-        elif network_id == "optimism-mainnet":
-            self._wallet_provider._network.network_id = "optimism"
-        elif network_id == "polygon-mainnet":
-            self._wallet_provider._network.network_id = "polygon"
-        elif network_id == "ethereum-mainnet":
-            self._wallet_provider._network.network_id = "ethereum"
-        return self._wallet_provider
-
-    async def get_account(self) -> EvmServerAccount:
-        """Get the account object from the wallet 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
-
-    async def get_provider_config(self) -> CdpEvmServerWalletProviderConfig:
-        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]
+    wallet_provider = await asyncio.to_thread(
+        CdpEvmWalletProvider, wallet_provider_config
+    )
+    _wallet_providers[agent.id] = (network_id, address, wallet_provider)
+    return wallet_provider

intentkit/{utils → clients}/s3.py

@@ -5,7 +5,7 @@ S3 utility module for storing and retrieving images from AWS S3.
 import logging
 from enum import Enum
 from io import BytesIO
-from typing import Optional
+from typing import cast
 
 import boto3
 import filetype
@@ -13,40 +13,58 @@ import httpx
 from botocore.exceptions import ClientError
 from mypy_boto3_s3.client import S3Client
 
+from intentkit.config.config import config
+
 logger = logging.getLogger(__name__)
 
 # Global variables for S3 configuration
-_bucket: Optional[str] = None
-_client: Optional[S3Client] = None
-_prefix: Optional[str] = None
-_cdn_url: Optional[str] = None
+_bucket: str | None = None
+_client: S3Client | None = None
+_prefix: str | None = None
+_cdn_url: str | None = None
 
 
-def init_s3(bucket: str, cdn_url: str, env: str) -> None:
+def get_s3_client() -> S3Client | None:
     """
-    Initialize S3 configuration.
-
-    Args:
-        bucket: S3 bucket name
-        cdn_url: CDN URL for the S3 bucket
-        env: Environment name for the prefix
-
-    Raises:
-        ValueError: If bucket or cdn_url is empty
+    Get or initialize S3 client and configuration.
+    Returns None if configuration is missing.
     """
     global _bucket, _client, _prefix, _cdn_url
 
-    if not bucket:
-        raise ValueError("S3 bucket name cannot be empty")
-    if not cdn_url:
-        raise ValueError("S3 CDN URL cannot be empty")
+    if _client is not None:
+        return _client
+
+    if not config.aws_s3_bucket or not config.aws_s3_cdn_url:
+        # Only log once or if needed, but here we just return None
+        # The calling functions usually log "S3 not initialized"
+        return None
 
-    _bucket = bucket
-    _cdn_url = cdn_url
-    _prefix = f"{env}/intentkit/"
-    _client = boto3.client("s3")
+    _bucket = config.aws_s3_bucket
+    _cdn_url = config.aws_s3_cdn_url
+    _prefix = f"{config.env}/intentkit/"
 
-    logger.info(f"S3 initialized with bucket: {bucket}, prefix: {_prefix}")
+    try:
+        if config.aws_s3_endpoint_url:
+            _client = cast(
+                S3Client,
+                boto3.client(
+                    "s3",
+                    endpoint_url=config.aws_s3_endpoint_url,
+                    region_name=config.aws_s3_region_name,
+                    aws_access_key_id=config.aws_s3_access_key_id,
+                    aws_secret_access_key=config.aws_s3_secret_access_key,
+                ),
+            )
+            logger.info(
+                f"S3 initialized with custom endpoint: {config.aws_s3_endpoint_url}, bucket: {_bucket}, prefix: {_prefix}"
+            )
+        else:
+            _client = cast(S3Client, boto3.client("s3"))
+            logger.info(f"S3 initialized with bucket: {_bucket}, prefix: {_prefix}")
+        return _client
+    except Exception as e:
+        logger.error(f"Failed to initialize S3 client: {e}")
+        return None
 
 
 async def store_image(url: str, key: str) -> str:
@@ -64,15 +82,16 @@ async def store_image(url: str, key: str) -> str:
         ClientError: If the upload fails
         httpx.HTTPError: If the download fails
     """
-    if not _client or not _bucket or not _prefix or not _cdn_url:
+    client = get_s3_client()
+    if not client or not _bucket or not _prefix or not _cdn_url:
         # If S3 is not initialized, log and return the original URL
         logger.info("S3 not initialized. Returning original URL.")
         return url
 
     try:
         # Download the image from the URL asynchronously
-        async with httpx.AsyncClient() as client:
-            response = await client.get(url, follow_redirects=True)
+        async with httpx.AsyncClient() as http_client:
+            response = await http_client.get(url, follow_redirects=True)
             response.raise_for_status()
 
             # Prepare the S3 key with prefix
@@ -93,7 +112,7 @@ async def store_image(url: str, key: str) -> str:
                     content_type = "image/jpeg"
 
             # Upload to S3
-            _client.upload_fileobj(
+            client.upload_fileobj(
                 file_obj,
                 _bucket,
                 prefixed_key,
@@ -114,7 +133,7 @@ async def store_image(url: str, key: str) -> str:
 
 
 async def store_image_bytes(
-    image_bytes: bytes, key: str, content_type: Optional[str] = None
+    image_bytes: bytes, key: str, content_type: str | None = None
 ) -> str:
     """
     Store raw image bytes to S3.
@@ -131,7 +150,8 @@ async def store_image_bytes(
         ClientError: If the upload fails
         ValueError: If S3 is not initialized or image_bytes is empty
     """
-    if not _client or not _bucket or not _prefix or not _cdn_url:
+    client = get_s3_client()
+    if not client or not _bucket or not _prefix or not _cdn_url:
         # If S3 is not initialized, log and return empty string
         logger.info("S3 not initialized. Cannot store image bytes.")
         return ""
@@ -158,7 +178,7 @@ async def store_image_bytes(
 
         logger.info("uploading image to s3")
         # Upload to S3
-        _client.upload_fileobj(
+        client.upload_fileobj(
             file_obj,
             _bucket,
             prefixed_key,
@@ -182,11 +202,65 @@ class FileType(str, Enum):
     PDF = "pdf"
 
 
+async def store_file(
+    content: bytes,
+    key: str,
+    content_type: str | None = None,
+    size: int | None = None,
+) -> str:
+    """Store raw file bytes with automatic content type detection."""
+    client = get_s3_client()
+    if not client or not _bucket or not _prefix or not _cdn_url:
+        logger.info("S3 not initialized. Cannot store file bytes.")
+        return ""
+
+    if not content:
+        raise ValueError("File content cannot be empty")
+
+    actual_size = len(content)
+    if size is not None and size != actual_size:
+        raise ValueError(
+            f"Provided size {size} does not match actual content size {actual_size} bytes"
+        )
+
+    effective_size = size if size is not None else actual_size
+
+    detected_content_type = content_type
+    if not detected_content_type:
+        kind = filetype.guess(content)
+        detected_content_type = (
+            kind.mime if kind and kind.mime else "application/octet-stream"
+        )
+
+    prefixed_key = f"{_prefix}{key}"
+    file_obj = BytesIO(content)
+
+    logger.info(
+        "Uploading file to S3 with content type %s and size %s bytes",
+        detected_content_type,
+        effective_size,
+    )
+
+    client.upload_fileobj(
+        file_obj,
+        _bucket,
+        prefixed_key,
+        ExtraArgs={
+            "ContentType": detected_content_type,
+            "ContentDisposition": "inline",
+        },
+    )
+
+    cdn_url = f"{_cdn_url}/{prefixed_key}"
+    logger.info("File uploaded successfully to %s", cdn_url)
+    return cdn_url
+
+
 async def store_file_bytes(
     file_bytes: bytes,
     key: str,
     file_type: FileType,
-    size_limit_bytes: Optional[int] = None,
+    size_limit_bytes: int | None = None,
 ) -> str:
     """
     Store raw file bytes (image, video, sound, pdf) to S3.
@@ -204,7 +278,8 @@ async def store_file_bytes(
         ClientError: If the upload fails
         ValueError: If S3 is not initialized, file_bytes is empty, or file exceeds size limit
     """
-    if not _client or not _bucket or not _prefix or not _cdn_url:
+    client = get_s3_client()
+    if not client or not _bucket or not _prefix or not _cdn_url:
         logger.info("S3 not initialized. Cannot store file bytes.")
         return ""
     if not file_bytes:
@@ -250,7 +325,7 @@ async def store_file_bytes(
         logger.info(f"Uploading {file_type} to S3 with content type {content_type}")
 
         # Upload to S3
-        _client.upload_fileobj(
+        client.upload_fileobj(
             file_obj,
             _bucket,
             prefixed_key,