intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__py3-none-any.whl

intentkit/skills/xmtp/price.py

@@ -1,8 +1,9 @@
-from typing import Literal, Type
+from typing import Literal
 
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.clients.cdp import get_origin_cdp_client
+from intentkit.clients.cdp import get_cdp_client
 from intentkit.skills.xmtp.base import XmtpBaseTool
 
 
@@ -21,9 +22,9 @@ class XmtpGetSwapPrice(XmtpBaseTool):
     """Skill for fetching indicative swap price using CDP SDK."""
 
     name: str = "xmtp_get_swap_price"
-    description: str = "Get an indicative swap price/quote for token pair and amount on Base networks using CDP."
+    description: str = "Get an indicative swap price/quote for token pair and amount on Ethereum, Base, Arbitrum, and Optimism mainnet networks using CDP."
     response_format: Literal["content", "content_and_artifact"] = "content"
-    args_schema: Type[BaseModel] = SwapPriceInput
+    args_schema: type[BaseModel] = SwapPriceInput
 
     async def _arun(
         self,
@@ -35,18 +36,22 @@ class XmtpGetSwapPrice(XmtpBaseTool):
         context = self.get_context()
         agent = context.agent
 
-        if agent.network_id not in ("base-mainnet", "base-sepolia"):
-            raise ValueError(
-                f"Swap price only supported on base-mainnet or base-sepolia. Current: {agent.network_id}"
+        # Only support mainnet networks for price and swap
+        supported_networks = [
+            "ethereum-mainnet",
+            "base-mainnet",
+            "arbitrum-mainnet",
+            "optimism-mainnet",
+        ]
+        if agent.network_id not in supported_networks:
+            raise ToolException(
+                f"Swap price only supported on {', '.join(supported_networks)}. Current: {agent.network_id}"
             )
 
-        network_for_cdp = {
-            "base-mainnet": "base",
-            "base-sepolia": "base-sepolia",
-        }[agent.network_id]
+        network_for_cdp = self.get_cdp_network(agent.network_id)
 
-        cdp_client = get_origin_cdp_client(self.skill_store)
-        # Note: Don't use async with context manager as get_origin_cdp_client returns a managed global client
+        cdp_client = get_cdp_client()
+        # Note: Don't use async with context manager as get_cdp_client returns a managed global client
         price = await cdp_client.evm.get_swap_price(
             from_token=from_token,
             to_token=to_token,

intentkit/skills/xmtp/schema.json

@@ -1,75 +1,73 @@
 {
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "type": "object",
-    "title": "XMTP",
-    "description": "Use this skill only if you want make an XMTP Agent. XMTP protocol skills for creating blockchain transaction requests that can be sent to users for signing",
-    "x-icon": "https://ai.service.crestal.dev/skills/xmtp/xmtp.png",
-    "x-tags": [
-        "XMTP",
-        "Blockchain",
-        "Transactions",
-        "Web3",
-        "Base"
-    ],
-    "properties": {
-        "enabled": {
-            "type": "boolean",
-            "title": "Enabled",
-            "description": "Whether this skill is enabled",
-            "default": false
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "XMTP",
+  "description": "Use this skill only if you want make an XMTP Agent. XMTP protocol skills for creating blockchain transaction requests that can be sent to users for signing",
+  "x-icon": "https://ai.service.crestal.dev/skills/xmtp/xmtp.png",
+  "x-tags": [
+    "Communication",
+    "Crypto",
+    "DeFi"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "xmtp_transfer": {
+          "type": "string",
+          "title": "XMTP Transfer",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Create XMTP transaction requests for transferring ETH or ERC20 tokens on Base mainnet. Supports both native ETH transfers and ERC20 token transfers. Generates wallet_sendCalls transaction data that users can sign.",
+          "default": "disabled"
         },
-        "states": {
-            "type": "object",
-            "properties": {
-                "xmtp_transfer": {
-                    "type": "string",
-                    "title": "XMTP Transfer",
-                    "enum": [
-                        "disabled",
-                        "public",
-                        "private"
-                    ],
-                    "x-enum-title": [
-                        "Disabled",
-                        "Agent Owner + All Users",
-                        "Agent Owner Only"
-                    ],
-                    "description": "Create XMTP transaction requests for transferring ETH or ERC20 tokens on Base mainnet. Supports both native ETH transfers and ERC20 token transfers. Generates wallet_sendCalls transaction data that users can sign.",
-                    "default": "disabled"
-                },
-                "xmtp_swap": {
-                    "type": "string",
-                    "title": "XMTP Swap",
-                    "enum": [
-                        "disabled",
-                        "public",
-                        "private"
-                    ],
-                    "x-enum-title": [
-                        "Disabled",
-                        "Agent Owner + All Users",
-                        "Agent Owner Only"
-                    ],
-                    "description": "Create XMTP transaction requests for swapping tokens on Base using CDP swap quote. Returns a wallet_sendCalls payload that can include an optional approval call and the swap call. Only supports base-mainnet and base-sepolia.",
-                    "default": "disabled"
-                },
-                "xmtp_get_swap_price": {
-                    "type": "string",
-                    "title": "XMTP Get Swap Price",
-                    "enum": [
-                        "disabled",
-                        "public",
-                        "private"
-                    ],
-                    "x-enum-title": [
-                        "Disabled",
-                        "Agent Owner + All Users",
-                        "Agent Owner Only"
-                    ],
-                    "description": "Get an indicative swap price/quote for token pair and amount on Base networks using CDP. Provides estimated output amounts for token swaps without creating transactions.",
-                    "default": "disabled"
-                }
-            }
+        "xmtp_swap": {
+          "type": "string",
+          "title": "XMTP Swap",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Create XMTP transaction requests for swapping tokens on Base using CDP swap quote. Returns a wallet_sendCalls payload that can include an optional approval call and the swap call. Only supports base-mainnet and base-sepolia.",
+          "default": "disabled"
+        },
+        "xmtp_get_swap_price": {
+          "type": "string",
+          "title": "XMTP Get Swap Price",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Get an indicative swap price/quote for token pair and amount on Base networks using CDP. Provides estimated output amounts for token swaps without creating transactions.",
+          "default": "disabled"
         }
+      }
     }
-}
+  }
+}

intentkit/skills/xmtp/swap.py

@@ -1,8 +1,6 @@
-from typing import List, Tuple, Type
-
 from pydantic import BaseModel, Field
 
-from intentkit.clients.cdp import get_origin_cdp_client
+from intentkit.clients.cdp import get_cdp_client
 from intentkit.models.chat import ChatMessageAttachment, ChatMessageAttachmentType
 from intentkit.skills.xmtp.base import XmtpBaseTool
 
@@ -33,16 +31,16 @@ class XmtpSwap(XmtpBaseTool):
 
     Generates a wallet_sendCalls transaction request to perform a token swap.
     May include an ERC20 approval call followed by the router swap call.
-    Supports Base mainnet and Base Sepolia testnet.
+    Supports Ethereum, Polygon, Base, Arbitrum, and Optimism networks (both mainnet and testnet).
     """
 
     name: str = "xmtp_swap"
     description: str = (
-        "Create an XMTP transaction request for swapping tokens on Base using CDP swap quote. "
+        "Create an XMTP transaction request for swapping tokens using CDP swap quote. "
         "Returns a wallet_sendCalls payload that can include an optional approval call and the swap call. "
-        "Only supports base-mainnet and base-sepolia."
+        "Supports Ethereum, Base, Arbitrum, and Optimism mainnet networks."
     )
-    args_schema: Type[BaseModel] = SwapInput
+    args_schema: type[BaseModel] = SwapInput
 
     async def _arun(
         self,
@@ -51,7 +49,7 @@ class XmtpSwap(XmtpBaseTool):
         to_token: str,
         from_amount: str,
         slippage_bps: int = 100,
-    ) -> Tuple[str, List[ChatMessageAttachment]]:
+    ) -> tuple[str, list[ChatMessageAttachment]]:
         # Input validation
         if (
             not from_address
@@ -87,36 +85,35 @@ class XmtpSwap(XmtpBaseTool):
         context = self.get_context()
         agent = context.agent
 
-        # ChainId mapping for XMTP wallet_sendCalls
-        chain_id_hex_by_network = {
-            "base-mainnet": "0x2105",  # 8453
-            "base-sepolia": "0x14A34",  # 84532
-        }
-
-        if agent.network_id not in chain_id_hex_by_network:
+        # Only support mainnet networks for swap
+        supported_networks = [
+            "ethereum-mainnet",
+            "base-mainnet",
+            "arbitrum-mainnet",
+            "optimism-mainnet",
+        ]
+        if agent.network_id not in supported_networks:
             raise ValueError(
-                f"XMTP swap only supports base-mainnet or base-sepolia. Current agent network: {agent.network_id}"
+                f"Swap only supported on {', '.join(supported_networks)}. Current: {agent.network_id}"
             )
 
-        chain_id_hex = chain_id_hex_by_network[agent.network_id]
+        # Validate network and get chain ID
+        chain_id_hex = self.validate_network_and_get_chain_id(agent.network_id, "swap")
 
-        # CDP network mapping for swap quote API
+        # Get CDP network name
         # Reference: CDP SDK examples for swap quote and price
         # https://github.com/coinbase/cdp-sdk/blob/main/examples/python/evm/swaps/create_swap_quote.py
-        network_for_cdp = {
-            "base-mainnet": "base",
-            "base-sepolia": "base-sepolia",
-        }[agent.network_id]
+        network_for_cdp = self.get_cdp_network(agent.network_id)
 
-        # Get CDP client from global origin helper (server-side credentials)
-        cdp_client = get_origin_cdp_client(self.skill_store)
+        # Get CDP client from the global helper (server-side credentials)
+        cdp_client = get_cdp_client()
 
         # Call CDP to create swap quote and extract call datas
         # Be permissive with response shape across SDK versions
         try:
             # Attempt the canonical method per CDP SDK examples
             # create_swap_quote(from_token, to_token, from_amount, network, taker, slippage_bps, signer_address)
-            # Note: Don't use async with context manager as get_origin_cdp_client returns a managed global client
+            # Note: Don't use async with context manager as get_cdp_client returns a managed global client
             quote = await cdp_client.evm.create_swap_quote(
                 from_token=from_token,
                 to_token=to_token,

intentkit/skills/xmtp/transfer.py

@@ -1,6 +1,5 @@
-from typing import List, Optional, Tuple, Type
-
 from pydantic import BaseModel, Field
+from web3.exceptions import ContractLogicError
 
 from intentkit.models.chat import ChatMessageAttachment, ChatMessageAttachmentType
 from intentkit.skills.xmtp.base import XmtpBaseTool
@@ -12,13 +11,10 @@ class TransferInput(BaseModel):
     from_address: str = Field(description="The sender address for the transfer")
     to_address: str = Field(description="The recipient address for the transfer")
     amount: str = Field(
-        description="The amount to transfer (as string to handle large numbers)"
-    )
-    decimals: int = Field(
-        description="Number of decimal places for the token (18 for ETH, varies for ERC20 tokens)"
+        description="The amount to transfer in human-readable format (e.g., '1.5' for 1.5 ETH, '100' for 100 USDC). Do NOT multiply by token decimals."
     )
-    currency: str = Field(description="Currency symbol (e.g., 'ETH', 'USDC', 'DAI')")
-    token_contract_address: Optional[str] = Field(
+    currency: str = Field(description="Currency symbol (e.g., 'ETH', 'USDC', 'NATION')")
+    token_contract_address: str | None = Field(
         default=None,
         description="Token contract address for ERC20 transfers. Leave empty for ETH transfers.",
     )
@@ -28,36 +24,29 @@ class XmtpTransfer(XmtpBaseTool):
     """Skill for creating XMTP transfer transactions."""
 
     name: str = "xmtp_transfer"
-    description: str = """Create an XMTP transaction request for transferring ETH or ERC20 tokens on Base mainnet.
-    
+    description: str = """Create an XMTP transaction request for transferring ETH or ERC20 tokens.
     This skill generates a wallet_sendCalls transaction request according to XMTP protocol 
-    that can be sent to users for signing. The transaction can transfer:
-    - ETH (when token_contract_address is not provided)
-    - ERC20 tokens (when token_contract_address is provided)
-    
-    Only supports Base mainnet network.
+    that can be sent to users for signing. 
+    Supports Ethereum, Polygon, Base, Arbitrum, and Optimism networks (both mainnet and testnet).
     """
-    args_schema: Type[BaseModel] = TransferInput
+    args_schema: type[BaseModel] = TransferInput
 
     async def _arun(
         self,
         from_address: str,
         to_address: str,
         amount: str,
-        decimals: int,
         currency: str,
-        token_contract_address: Optional[str],
-    ) -> Tuple[str, List[ChatMessageAttachment]]:
+        token_contract_address: str | None,
+    ) -> tuple[str, list[ChatMessageAttachment]]:
         """Create an XMTP transfer transaction request.
 
         Args:
             from_address: The sender address
             to_address: The recipient address
             amount: Amount to transfer
-            decimals: Token decimals
             currency: Currency symbol
             token_contract_address: Token contract address (None for ETH)
-            config: LangChain runnable config
 
         Returns:
             Tuple of (content_message, list_of_attachments)
@@ -66,19 +55,69 @@ class XmtpTransfer(XmtpBaseTool):
         context = self.get_context()
         agent = context.agent
 
-        # ChainId mapping for XMTP wallet_sendCalls
-        chain_id_hex_by_network = {
-            "base-mainnet": "0x2105",  # 8453
-            "base-sepolia": "0x14A34",  # 84532
-        }
+        # Validate network and get chain ID
+        chain_id_hex = self.validate_network_and_get_chain_id(
+            agent.network_id, "transfer"
+        )
 
-        if agent.network_id not in chain_id_hex_by_network:
-            raise ValueError(
-                f"XMTP transfer only supports base-mainnet or base-sepolia network. "
-                f"Current agent network: {agent.network_id}"
-            )
+        # Validate token contract and get decimals
+        if token_contract_address:
+            # Validate ERC20 contract and get token info
+            web3 = self.web3_client()
 
-        chain_id_hex = chain_id_hex_by_network[agent.network_id]
+            # ERC20 ABI for symbol() and decimals() functions
+            erc20_abi = [
+                {
+                    "constant": True,
+                    "inputs": [],
+                    "name": "symbol",
+                    "outputs": [{"name": "", "type": "string"}],
+                    "type": "function",
+                },
+                {
+                    "constant": True,
+                    "inputs": [],
+                    "name": "decimals",
+                    "outputs": [{"name": "", "type": "uint8"}],
+                    "type": "function",
+                },
+            ]
+
+            try:
+                # Create contract instance
+                contract = web3.eth.contract(
+                    address=web3.to_checksum_address(token_contract_address),
+                    abi=erc20_abi,
+                )
+
+                # Get token symbol and decimals
+                token_symbol = contract.functions.symbol().call()
+                decimals = contract.functions.decimals().call()
+
+                # Validate symbol matches currency (case insensitive)
+                if token_symbol.upper() != currency.upper():
+                    raise ValueError(
+                        f"Token symbol mismatch: contract symbol is '{token_symbol}', "
+                        f"but currency parameter is '{currency}'"
+                    )
+
+            except ContractLogicError:
+                raise ValueError(
+                    f"Invalid ERC20 contract address: {token_contract_address}. "
+                    "The address does not point to a valid ERC20 token contract."
+                )
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to validate ERC20 contract {token_contract_address}: {str(e)}"
+                )
+        else:
+            # For ETH transfers, use 18 decimals
+            decimals = 18
+            # Validate currency is ETH for native transfers
+            if currency.upper() != "ETH":
+                raise ValueError(
+                    f"For native transfers, currency must be 'ETH', got '{currency}'"
+                )
 
         # Calculate amount in smallest unit (wei for ETH, token units for ERC20)
         amount_int = int(float(amount) * (10**decimals))

intentkit/utils/chain.py

@@ -422,9 +422,9 @@ class QuicknodeChainProvider(ChainProvider):
                     )
 
             except httpx.HTTPStatusError as http_err:
-                raise (f"Quicknode API HTTP Error: {http_err}")
+                raise Exception(f"Quicknode API HTTP Error: {http_err}")
             except httpx.RequestError as req_err:
-                raise (f"Quicknode API Request Error: {req_err}")
+                raise Exception(f"Quicknode API Request Error: {req_err}")
             except (
                 KeyError,
                 TypeError,
@@ -433,4 +433,4 @@ class QuicknodeChainProvider(ChainProvider):
                     f"Error processing QuickNode API response: {e}. Check the API response format."
                 )
             except Exception as e:
-                raise (f"Quicknode API An unexpected error occurred: {e}")
+                raise Exception(f"Quicknode API An unexpected error occurred: {e}")

intentkit/utils/error.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Sequence
+from collections.abc import Sequence
 
 from fastapi.exceptions import RequestValidationError
 from fastapi.utils import is_body_allowed_for_status_code
@@ -11,8 +11,21 @@ from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY
 
 logger = logging.getLogger(__name__)
 
+# error messages in agent system message response
+
+
+class RateLimitExceeded(Exception):
+    """Rate limit exceeded"""
+
+    def __init__(self, message: str | None = "Rate limit exceeded"):
+        self.message = message
+        super().__init__(self.message)
+
 
 class IntentKitAPIError(Exception):
+    """All 3 parameters: status_code, key and message is required.
+    The key is PascalCase string, to allow the frontend to test errors."""
+
     def __init__(self, status_code: int, key: str, message: str):
         self.key = key
         self.message = message

intentkit/utils/logging.py

@@ -4,13 +4,11 @@ Logging configuration module
 
 import json
 import logging
-from typing import Callable, Optional
+from collections.abc import Callable
 
 
 class JsonFormatter(logging.Formatter):
-    def __init__(
-        self, filter_func: Optional[Callable[[logging.LogRecord], bool]] = None
-    ):
+    def __init__(self, filter_func: Callable[[logging.LogRecord], bool] | None = None):
         super().__init__()
         self.filter_func = filter_func
 

intentkit/utils/s3.py

@@ -5,7 +5,6 @@ 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
 
 import boto3
 import filetype
@@ -16,10 +15,10 @@ from mypy_boto3_s3.client import S3Client
 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:
@@ -114,7 +113,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.
@@ -182,11 +181,64 @@ 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."""
+    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.