intentkit 0.6.11.dev3__tar.gz → 0.6.11.dev4__tar.gz

{intentkit-0.6.11.dev3 → intentkit-0.6.11.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.6.11.dev3
+Version: 0.6.11.dev4
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestal-network/intentkit
 Project-URL: Repository, https://github.com/crestal-network/intentkit

{intentkit-0.6.11.dev3 → intentkit-0.6.11.dev4}/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.6.11-dev3"
+__version__ = "0.6.11-dev4"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

{intentkit-0.6.11.dev3 → intentkit-0.6.11.dev4}/clients/cdp.py

@@ -17,6 +17,7 @@ from intentkit.models.agent import Agent
 from intentkit.models.agent_data import AgentData
 
 _clients: Dict[str, "CdpClient"] = {}
+_origin_cdp_client: Optional[OriginCdpClient] = None
 
 logger = logging.getLogger(__name__)
 
@@ -56,6 +57,24 @@ def bip39_seed_to_eth_keys(seed_hex: str) -> Dict[str, str]:
     }
 
 
+def get_origin_cdp_client(skill_store: SkillStoreABC) -> OriginCdpClient:
+    global _origin_cdp_client
+    if _origin_cdp_client:
+        return _origin_cdp_client
+
+    # 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
@@ -81,11 +100,7 @@ class CdpClient:
         # new agent or address not migrated yet
         if not address:
             # create cdp client for later use
-            cdp_client = OriginCdpClient(
-                api_key_id=api_key_id,
-                api_key_secret=api_key_secret,
-                wallet_secret=wallet_secret,
-            )
+            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)
@@ -115,8 +130,7 @@ class CdpClient:
                 address = new_account.address
                 logger.info("Created new wallet: %s", address)
 
-            # close client
-            await cdp_client.close()
+            # 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()

{intentkit-0.6.11.dev3 → intentkit-0.6.11.dev4}/models/llm.py

@@ -628,9 +628,10 @@ class DeepseekLLM(LLMModel):
         info = await self.model_info()
 
         kwargs = {
-            "model_name": self.model_name,
-            "openai_api_key": config.deepseek_api_key,
+            "model": self.model_name,
+            "api_key": config.deepseek_api_key,
             "timeout": info.timeout,
+            "max_retries": 3,
         }
 
         # Add optional parameters based on model support
@@ -644,7 +645,7 @@ class DeepseekLLM(LLMModel):
             kwargs["presence_penalty"] = self.presence_penalty
 
         if info.api_base:
-            kwargs["openai_api_base"] = info.api_base
+            kwargs["api_base"] = info.api_base
 
         return ChatDeepSeek(**kwargs)
 

{intentkit-0.6.11.dev3 → intentkit-0.6.11.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.6.11-dev3"
+version = "0.6.11-dev4"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"

{intentkit-0.6.11.dev3 → intentkit-0.6.11.dev4}/skills/xmtp/__init__.py

@@ -6,6 +6,8 @@ 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
+from intentkit.skills.xmtp.swap import XmtpSwap
 from intentkit.skills.xmtp.transfer import XmtpTransfer
 
 # Cache skills at the module level, because they are stateless
@@ -16,6 +18,8 @@ logger = logging.getLogger(__name__)
 
 class SkillStates(TypedDict):
     xmtp_transfer: SkillState
+    xmtp_swap: SkillState
+    xmtp_get_swap_price: SkillState
 
 
 class Config(SkillConfig):
@@ -77,6 +81,18 @@ def get_xmtp_skill(
                 skill_store=store,
             )
         return _cache[name]
+    elif name == "xmtp_swap":
+        if name not in _cache:
+            _cache[name] = XmtpSwap(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "xmtp_get_swap_price":
+        if name not in _cache:
+            _cache[name] = XmtpGetSwapPrice(
+                skill_store=store,
+            )
+        return _cache[name]
     else:
         logger.warning(f"Unknown XMTP skill: {name}")
         return None

intentkit-0.6.11.dev4/skills/xmtp/price.py

@@ -0,0 +1,72 @@
+from typing import Literal, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.clients.cdp import get_origin_cdp_client
+from intentkit.skills.xmtp.base import XmtpBaseTool
+
+
+class SwapPriceInput(BaseModel):
+    """Input for querying swap price via CDP."""
+
+    from_token: str = Field(description="The contract address to swap from")
+    to_token: str = Field(description="The contract address to swap to")
+    from_amount: str = Field(description="Input amount in smallest units (as string)")
+    from_address: str = Field(
+        description="The address where the from_token balance is located"
+    )
+
+
+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."
+    response_format: Literal["content", "content_and_artifact"] = "content"
+    args_schema: Type[BaseModel] = SwapPriceInput
+
+    async def _arun(
+        self,
+        from_token: str,
+        to_token: str,
+        from_amount: str,
+        from_address: str,
+    ) -> str:
+        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}"
+            )
+
+        network_for_cdp = {
+            "base-mainnet": "base",
+            "base-sepolia": "base-sepolia",
+        }[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
+        price = await cdp_client.evm.get_swap_price(
+            from_token=from_token,
+            to_token=to_token,
+            from_amount=str(from_amount),
+            network=network_for_cdp,
+            taker=from_address,
+        )
+
+        # Try to format a readable message from typical fields
+        try:
+            amount_out = getattr(price, "to_amount", None) or (
+                price.get("to_amount") if isinstance(price, dict) else None
+            )
+            route = getattr(price, "route", None) or (
+                price.get("route") if isinstance(price, dict) else None
+            )
+            route_str = f" via {route}" if route else ""
+            if amount_out:
+                return f"Estimated output: {amount_out} units of {to_token}{route_str} on {agent.network_id}."
+        except Exception:
+            pass
+
+        return f"Swap price result (raw): {price}"

intentkit-0.6.11.dev4/skills/xmtp/swap.py

@@ -0,0 +1,204 @@
+from typing import List, Tuple, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.clients.cdp import get_origin_cdp_client
+from intentkit.models.chat import ChatMessageAttachment, ChatMessageAttachmentType
+from intentkit.skills.xmtp.base import XmtpBaseTool
+
+
+class SwapInput(BaseModel):
+    """Input for XMTP swap skill.
+
+    This creates an unsigned swap transaction attachment using CDP swap quote
+    that a user can review and sign via XMTP wallet_sendCalls.
+    """
+
+    from_address: str = Field(description="The sender address for the swap")
+    from_token: str = Field(
+        description="The contract address of the token to swap from"
+    )
+    to_token: str = Field(description="The contract address of the token to swap to")
+    from_amount: str = Field(
+        description="The input amount in the smallest unit of from_token (as string)"
+    )
+    slippage_bps: int = Field(
+        default=100,
+        description="Maximum slippage in basis points (100 = 1%). Defaults to 100.",
+    )
+
+
+class XmtpSwap(XmtpBaseTool):
+    """Skill for creating XMTP swap transactions using CDP swap quote.
+
+    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.
+    """
+
+    name: str = "xmtp_swap"
+    description: str = (
+        "Create an XMTP transaction request 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."
+    )
+    args_schema: Type[BaseModel] = SwapInput
+
+    async def _arun(
+        self,
+        from_address: str,
+        from_token: str,
+        to_token: str,
+        from_amount: str,
+        slippage_bps: int = 100,
+    ) -> Tuple[str, List[ChatMessageAttachment]]:
+        # Resolve agent context and target network
+        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:
+            raise ValueError(
+                f"XMTP swap only supports base-mainnet or base-sepolia. Current agent network: {agent.network_id}"
+            )
+
+        chain_id_hex = chain_id_hex_by_network[agent.network_id]
+
+        # CDP network mapping for swap quote API
+        # 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]
+
+        # Get CDP client from global origin helper (server-side credentials)
+        cdp_client = get_origin_cdp_client(self.skill_store)
+
+        # 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
+            quote = await cdp_client.evm.create_swap_quote(
+                from_token=from_token,
+                to_token=to_token,
+                from_amount=str(from_amount),
+                network=network_for_cdp,
+                taker=from_address,
+                slippage_bps=slippage_bps,
+                signer_address=from_address,
+            )
+        except Exception as e:  # pragma: no cover - defensive
+            raise ValueError(f"Failed to create swap quote via CDP: {e!s}")
+
+        # Extract approval and swap calls if present (prefer QuoteSwapResult canonical fields)
+        calls: list[dict] = []
+
+        def to_xmtp_call(call_like, description: str) -> dict | None:
+            if not call_like:
+                return None
+            # Attributes on QuoteSwapResult call-like objects
+            to_value = getattr(call_like, "to", None) or getattr(
+                call_like, "target", None
+            )
+            data_value = getattr(call_like, "data", None) or getattr(
+                call_like, "calldata", None
+            )
+            value_value = getattr(call_like, "value", None)
+            # Dict fallback
+            if isinstance(call_like, dict):
+                to_value = to_value or call_like.get("to") or call_like.get("target")
+                data_value = (
+                    data_value or call_like.get("data") or call_like.get("calldata")
+                )
+                value_value = value_value or call_like.get("value")
+            if not to_value or not data_value:
+                return None
+            value_hex = (
+                value_value
+                if isinstance(value_value, str) and value_value.startswith("0x")
+                else (hex(int(value_value)) if value_value is not None else "0x0")
+            )
+            data_hex = (
+                data_value if str(data_value).startswith("0x") else f"0x{data_value}"
+            )
+            return {
+                "to": to_value,
+                "value": value_hex,
+                "data": data_hex,
+                "metadata": {
+                    "description": description,
+                    "transactionType": "swap_step",
+                    "fromToken": from_token,
+                    "toToken": to_token,
+                    "amountIn": from_amount,
+                    "slippageBps": slippage_bps,
+                },
+            }
+
+        # Heuristics for various response shapes
+        approval = (
+            getattr(quote, "approval", None)
+            or getattr(quote, "approval_call_data", None)
+            or (quote.get("approval") if isinstance(quote, dict) else None)
+            or (quote.get("approval_call_data") if isinstance(quote, dict) else None)
+        )
+        approval_xmtp = to_xmtp_call(approval, "Approve token spending if required")
+        if approval_xmtp:
+            calls.append(approval_xmtp)
+
+        swap_call = (
+            getattr(quote, "swap", None)
+            or getattr(quote, "swap_call_data", None)
+            or (quote.get("swap") if isinstance(quote, dict) else None)
+            or (quote.get("swap_call_data") if isinstance(quote, dict) else None)
+        )
+        swap_xmtp = to_xmtp_call(swap_call, "Execute token swap")
+        if swap_xmtp:
+            calls.append(swap_xmtp)
+
+        if not calls:
+            # As a final fallback, some responses may provide a generic 'calls' list
+            raw_calls = getattr(quote, "calls", None) or (
+                quote.get("calls") if isinstance(quote, dict) else None
+            )
+            if isinstance(raw_calls, list):
+                for idx, c in enumerate(raw_calls):
+                    x = to_xmtp_call(c, f"Swap step {idx + 1}")
+                    if x:
+                        calls.append(x)
+
+        if not calls:
+            raise ValueError(
+                "CDP swap quote did not return callable steps compatible with wallet_sendCalls"
+            )
+
+        # Build XMTP wallet_sendCalls payload
+        wallet_send_calls = {
+            "version": "1.0",
+            "from": from_address,
+            "chainId": chain_id_hex,
+            "calls": calls,
+        }
+
+        # Attachment for chat
+        attachment: ChatMessageAttachment = {
+            "type": ChatMessageAttachmentType.XMTP,
+            "url": None,
+            "json": wallet_send_calls,
+        }
+
+        # Human-friendly message
+        content_message = (
+            f"I created a swap transaction request to exchange {from_amount} units of {from_token} "
+            f"for {to_token} on {agent.network_id}. Review and sign to execute."
+        )
+
+        return content_message, [attachment]