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

intentkit/skills/x402/ask_agent.py

@@ -0,0 +1,98 @@
+import logging
+from typing import Any
+
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.config.config import config
+from intentkit.models.chat import AuthorType
+from intentkit.skills.x402.base import X402BaseSkill
+
+logger = logging.getLogger(__name__)
+
+
+class AskAgentInput(BaseModel):
+    """Arguments for the x402 ask agent skill."""
+
+    agent_id: str = Field(description="ID or slug of the agent to query.")
+    message: str = Field(description="Message to send to the target agent.")
+    search_mode: bool | None = Field(
+        default=None, description="Enable search mode when interacting with the agent."
+    )
+    super_mode: bool | None = Field(
+        default=None, description="Enable super mode when interacting with the agent."
+    )
+
+
+class X402AskAgent(X402BaseSkill):
+    """Skill that queries another agent via the x402 API."""
+
+    name: str = "x402_ask_agent"
+    description: str = (
+        "Call another agent through the x402 API and return the final agent message."
+    )
+    args_schema: type[BaseModel] = AskAgentInput
+
+    async def _arun(
+        self,
+        agent_id: str,
+        message: str,
+        search_mode: bool | None = None,
+        super_mode: bool | None = None,
+    ) -> str:
+        try:
+            # Use wallet provider signer to satisfy eth_account.BaseAccount interface requirements
+            base_url = (config.open_api_base_url or "").rstrip("/")
+            if not base_url:
+                raise ToolException("X402 API base URL is not configured.")
+            target_url = f"{base_url}/x402"
+            payload: dict[str, Any] = {
+                "agent_id": agent_id,
+                "message": message,
+                "app_id": "skill",
+            }
+            if search_mode is not None:
+                payload["search_mode"] = search_mode
+            if super_mode is not None:
+                payload["super_mode"] = super_mode
+
+            async with self.http_client(timeout=20.0) as client:
+                response = await client.post(target_url, json=payload)
+                try:
+                    response.raise_for_status()
+                except Exception as e:
+                    error_body = ""
+                    try:
+                        error_body = response.text
+                    except Exception:
+                        error_body = "Unable to read response body"
+                    logger.error(
+                        f"HTTP request failed with status {response.status_code}: {error_body}"
+                    )
+                    raise ToolException(
+                        f"HTTP request failed with status {response.status_code}: {error_body}"
+                    ) from e
+                messages = response.json()
+            if not isinstance(messages, list) or not messages:
+                raise ValueError("Agent returned an empty response.")
+
+            last_message = messages[-1]
+            if not isinstance(last_message, dict):
+                raise ValueError("Agent response format is invalid.")
+
+            author_type = last_message.get("author_type")
+            content = last_message.get("message")
+
+            if author_type == AuthorType.SYSTEM.value:
+                raise ToolException(content or "Agent returned a system message.")
+
+            if not content:
+                raise ToolException("Agent response did not include message text.")
+
+            return str(content)
+        except ToolException:
+            # Re-raise ToolException as-is
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error in x402_ask_agent: {str(e)}")
+            raise ToolException(f"Unexpected error occurred: {str(e)}") from e

intentkit/skills/x402/base.py

@@ -0,0 +1,99 @@
+import logging
+import threading
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from coinbase_agentkit.wallet_providers.evm_wallet_provider import (
+    EvmWalletSigner as CoinbaseEvmWalletSigner,
+)
+from x402.clients.httpx import x402HttpxClient
+
+from intentkit.clients import get_wallet_provider
+from intentkit.skills.onchain import IntentKitOnChainSkill
+
+logger = logging.getLogger(__name__)
+
+
+class X402BaseSkill(IntentKitOnChainSkill):
+    """Base class for x402 skills."""
+
+    @property
+    def category(self) -> str:
+        return "x402"
+
+    async def _get_signer(self) -> "ThreadSafeEvmWalletSigner":
+        context = self.get_context()
+        wallet_provider = await get_wallet_provider(context.agent)
+        return ThreadSafeEvmWalletSigner(wallet_provider)
+
+    @asynccontextmanager
+    async def http_client(
+        self,
+        timeout: float = 30.0,
+    ) -> AsyncIterator[x402HttpxClient]:
+        account = await self._get_signer()
+        try:
+            async with x402HttpxClient(
+                account=account,
+                timeout=timeout,
+            ) as client:
+                yield client
+        except Exception:
+            logger.exception("Failed to create x402 HTTP client")
+            raise
+
+
+class ThreadSafeEvmWalletSigner(CoinbaseEvmWalletSigner):
+    """EVM wallet signer that avoids nested event loop errors.
+
+    Coinbase's signer runs async wallet calls in the current thread. When invoked
+    inside an active asyncio loop (as happens in async skills), it trips over the
+    loop already running. We hop work to a background thread so the provider can
+    spin up its own loop safely.
+    """
+
+    def __init__(self, wallet_provider: Any):
+        super().__init__(wallet_provider=wallet_provider)
+
+    def _run_in_thread(self, func: Any, *args: Any, **kwargs: Any) -> Any:
+        result: list[Any] = []
+        error: list[BaseException] = []
+
+        def _target() -> None:
+            try:
+                result.append(func(*args, **kwargs))
+            except BaseException as exc:  # pragma: no cover - bubble up original error
+                error.append(exc)
+
+        thread = threading.Thread(target=_target, daemon=True)
+        thread.start()
+        thread.join()
+
+        if error:
+            raise error[0]
+        return result[0] if result else None
+
+    def unsafe_sign_hash(self, message_hash: Any) -> Any:
+        return self._run_in_thread(super().unsafe_sign_hash, message_hash)
+
+    def sign_message(self, signable_message: Any) -> Any:
+        return self._run_in_thread(super().sign_message, signable_message)
+
+    def sign_transaction(self, transaction_dict: Any) -> Any:
+        return self._run_in_thread(super().sign_transaction, transaction_dict)
+
+    def sign_typed_data(
+        self,
+        domain_data: Any | None = None,
+        message_types: Any | None = None,
+        message_data: Any | None = None,
+        full_message: Any | None = None,
+    ) -> Any:
+        return self._run_in_thread(
+            super().sign_typed_data,
+            domain_data=domain_data,
+            message_types=message_types,
+            message_data=message_data,
+            full_message=full_message,
+        )

intentkit/skills/x402/http_request.py

@@ -0,0 +1,117 @@
+import logging
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.skills.x402.base import X402BaseSkill
+
+logger = logging.getLogger(__name__)
+
+
+class X402HttpRequestInput(BaseModel):
+    """Arguments for a generic x402 HTTP request."""
+
+    method: str = Field(description="HTTP method to use. Supported values: GET, POST.")
+    url: str = Field(
+        description="Absolute URL for the request (must include scheme and host)."
+    )
+    headers: dict[str, str] | None = Field(
+        default=None,
+        description="Optional headers to include in the request.",
+    )
+    params: dict[str, Any] | None = Field(
+        default=None,
+        description="Optional query parameters to include in the request.",
+    )
+    data: dict[str, Any] | str | None = Field(
+        default=None,
+        description=(
+            "Optional request body. Dictionaries are sent as JSON; strings are sent as raw data. "
+            "Only supported for POST requests."
+        ),
+    )
+    timeout: float | None = Field(
+        default=30.0,
+        description="Request timeout in seconds.",
+    )
+
+
+class X402HttpRequest(X402BaseSkill):
+    """Skill that performs signed HTTP requests via the x402 client."""
+
+    name: str = "x402_http_request"
+    description: str = (
+        "Send an HTTP GET or POST request using the x402 payment protocol. "
+        "Provide the method, absolute URL, optional headers, query parameters, and request body. "
+        "Returns the response status and body text."
+    )
+    args_schema: type[BaseModel] = X402HttpRequestInput
+
+    async def _arun(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str] | None = None,
+        params: dict[str, Any] | None = None,
+        data: dict[str, Any] | str | None = None,
+        timeout: float = 30.0,
+        **_: Any,
+    ) -> str:
+        method_upper = method.upper()
+        if method_upper not in {"GET", "POST"}:
+            raise ToolException(
+                f"Unsupported HTTP method '{method}'. Only GET and POST are allowed."
+            )
+
+        parsed = urlparse(url)
+        if not (parsed.scheme and parsed.netloc):
+            raise ToolException("URL must include scheme and host (absolute URL).")
+
+        request_headers = dict(headers or {})
+        request_kwargs: dict[str, Any] = {
+            "url": url,
+            "headers": request_headers or None,
+            "params": params,
+            "timeout": timeout,
+        }
+
+        if method_upper == "POST":
+            if isinstance(data, dict):
+                header_keys = {key.lower() for key in request_headers}
+                if "content-type" not in header_keys:
+                    request_headers["Content-Type"] = "application/json"
+                request_kwargs["json"] = data
+            elif isinstance(data, str):
+                request_kwargs["content"] = data
+            elif data is not None:
+                raise ToolException(
+                    "POST body must be either a JSON-serializable object or a string."
+                )
+        elif data is not None:
+            raise ToolException("Request body is only supported for POST requests.")
+
+        try:
+            async with self.http_client(timeout=timeout) as client:
+                response = await client.request(method_upper, **request_kwargs)
+                response.raise_for_status()
+                return f"Status: {response.status_code}\nContent: {response.text}"
+        except ValueError as exc:
+            raise ToolException(str(exc)) from exc
+        except httpx.TimeoutException as exc:
+            raise ToolException(
+                f"Request to {url} timed out after {timeout} seconds"
+            ) from exc
+        except httpx.HTTPStatusError as exc:
+            raise ToolException(
+                f"HTTP {exc.response.status_code} - {exc.response.text}"
+            ) from exc
+        except httpx.RequestError as exc:
+            raise ToolException(f"Failed to connect to {url} - {str(exc)}") from exc
+        except ToolException:
+            raise
+        except Exception as exc:
+            logger.error("Unexpected error in x402_http_request", exc_info=exc)
+            raise ToolException(f"Unexpected error occurred - {str(exc)}") from exc

intentkit/skills/x402/schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "x402",
+  "description": "Interact with other IntentKit agents through the x402 payment protocol.",
+  "x-icon": "https://ai.service.crestal.dev/skills/x402/x402.webp",
+  "x-tags": ["Communication", "Infrastructure"],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill category is enabled.",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "x402_ask_agent": {
+          "type": "string",
+          "title": "Ask Agent",
+          "enum": ["disabled", "public", "private"],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Send a message to another IntentKit agent via the x402 API and return the final agent response.",
+          "default": "disabled"
+        },
+        "x402_http_request": {
+          "type": "string",
+          "title": "HTTP Request",
+          "enum": ["disabled", "public", "private"],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Perform a signed HTTP GET or POST request via the x402 payment protocol.",
+          "default": "disabled"
+        }
+      }
+    }
+  }
+}

intentkit/skills/xmtp/__init__.py

@@ -3,7 +3,6 @@
 import logging
 from typing import TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.xmtp.base import XmtpBaseTool
 from intentkit.skills.xmtp.price import XmtpGetSwapPrice
@@ -31,7 +30,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[XmtpBaseTool]:
     """Get all XMTP skills.
@@ -39,7 +37,6 @@ async def get_skills(
     Args:
         config: The configuration for XMTP skills.
         is_private: Whether to include private skills.
-        store: The skill store for persisting data.
 
     Returns:
         A list of XMTP skills.
@@ -56,7 +53,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_xmtp_skill(name, store)
+        skill = get_xmtp_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -64,34 +61,26 @@ async def get_skills(
 
 def get_xmtp_skill(
     name: str,
-    store: SkillStoreABC,
 ) -> XmtpBaseTool:
     """Get an XMTP skill by name.
 
     Args:
         name: The name of the skill to get
-        store: The skill store for persisting data
 
     Returns:
         The requested XMTP skill
     """
     if name == "xmtp_transfer":
         if name not in _cache:
-            _cache[name] = XmtpTransfer(
-                skill_store=store,
-            )
+            _cache[name] = XmtpTransfer()
         return _cache[name]
     elif name == "xmtp_swap":
         if name not in _cache:
-            _cache[name] = XmtpSwap(
-                skill_store=store,
-            )
+            _cache[name] = XmtpSwap()
         return _cache[name]
     elif name == "xmtp_get_swap_price":
         if name not in _cache:
-            _cache[name] = XmtpGetSwapPrice(
-                skill_store=store,
-            )
+            _cache[name] = XmtpGetSwapPrice()
         return _cache[name]
     else:
         logger.warning(f"Unknown XMTP skill: {name}")

intentkit/skills/xmtp/base.py

@@ -1,16 +1,16 @@
-from typing import Dict, Literal
+from typing import Literal
 
-from intentkit.skills.base import IntentKitSkill
+from intentkit.skills.onchain import IntentKitOnChainSkill
 
 
-class XmtpBaseTool(IntentKitSkill):
+class XmtpBaseTool(IntentKitOnChainSkill):
     """Base class for XMTP-related skills."""
 
     # Set response format to content_and_artifact for returning tuple
     response_format: Literal["content", "content_and_artifact"] = "content_and_artifact"
 
     # ChainId mapping for XMTP wallet_sendCalls (mainnet only)
-    CHAIN_ID_HEX_BY_NETWORK: Dict[str, str] = {
+    CHAIN_ID_HEX_BY_NETWORK: dict[str, str] = {
         "ethereum-mainnet": "0x1",  # 1
         "base-mainnet": "0x2105",  # 8453
         "arbitrum-mainnet": "0xA4B1",  # 42161
@@ -18,7 +18,7 @@ class XmtpBaseTool(IntentKitSkill):
     }
 
     # CDP network mapping for swap quote API (mainnet only)
-    NETWORK_FOR_CDP_MAPPING: Dict[str, str] = {
+    NETWORK_FOR_CDP_MAPPING: dict[str, str] = {
         "ethereum-mainnet": "ethereum",
         "base-mainnet": "base",
         "arbitrum-mainnet": "arbitrum",

intentkit/skills/xmtp/price.py

@@ -1,9 +1,9 @@
-from typing import Literal, Type
+from typing import Literal
 
-from langchain.tools.base import ToolException
+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
 
 
@@ -24,7 +24,7 @@ class XmtpGetSwapPrice(XmtpBaseTool):
     name: str = "xmtp_get_swap_price"
     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,
@@ -50,8 +50,8 @@ class XmtpGetSwapPrice(XmtpBaseTool):
 
         network_for_cdp = self.get_cdp_network(agent.network_id)
 
-        cdp_client = get_origin_cdp_client()
-        # 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/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
 
@@ -42,7 +40,7 @@ class XmtpSwap(XmtpBaseTool):
         "Returns a wallet_sendCalls payload that can include an optional approval call and the swap call. "
         "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
@@ -107,15 +105,15 @@ class XmtpSwap(XmtpBaseTool):
         # https://github.com/coinbase/cdp-sdk/blob/main/examples/python/evm/swaps/create_swap_quote.py
         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()
+        # 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,5 +1,3 @@
-from typing import List, Optional, Tuple, Type
-
 from pydantic import BaseModel, Field
 from web3.exceptions import ContractLogicError
 
@@ -16,7 +14,7 @@ class TransferInput(BaseModel):
         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', 'NATION')")
-    token_contract_address: Optional[str] = Field(
+    token_contract_address: str | None = Field(
         default=None,
         description="Token contract address for ERC20 transfers. Leave empty for ETH transfers.",
     )
@@ -31,7 +29,7 @@ class XmtpTransfer(XmtpBaseTool):
     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,
@@ -39,8 +37,8 @@ class XmtpTransfer(XmtpBaseTool):
         to_address: str,
         amount: str,
         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:

intentkit/utils/error.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Optional, Sequence
+from collections.abc import Sequence
 
 from fastapi.exceptions import RequestValidationError
 from fastapi.utils import is_body_allowed_for_status_code
@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
 class RateLimitExceeded(Exception):
     """Rate limit exceeded"""
 
-    def __init__(self, message: Optional[str] = "Rate limit exceeded"):
+    def __init__(self, message: str | None = "Rate limit exceeded"):
         self.message = message
         super().__init__(self.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.
@@ -185,8 +184,8 @@ class FileType(str, Enum):
 async def store_file(
     content: bytes,
     key: str,
-    content_type: Optional[str] = None,
-    size: Optional[int] = None,
+    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:
@@ -239,7 +238,7 @@ 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.