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

intentkit/skills/enso/wallet.py

@@ -1,26 +1,16 @@
-from typing import Literal, Tuple, Type
+from typing import Literal
 
 import httpx
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from .base import EnsoBaseTool, base_url, default_chain_id
+from .base import EnsoBaseTool, base_url
 
 
 class EnsoGetBalancesInput(BaseModel):
-    """
-    Input model for retrieving wallet balances.
-    """
+    """Input model for retrieving wallet balances."""
 
-    chainId: int = Field(
-        default_chain_id, description="Chain ID of the blockchain network"
-    )
-    # eoaAddress: str = Field(
-    #     description="Address of the eoa with which to associate the ensoWallet for balances"
-    # )
-    # useEoa: bool = Field(
-    #     description="If true returns balances for the provided eoaAddress, instead of the associated ensoWallet"
-    # )
+    chainId: int | None = Field(None, description="Chain ID of the blockchain network")
 
 
 class WalletBalance(BaseModel):
@@ -31,9 +21,7 @@ class WalletBalance(BaseModel):
 
 
 class EnsoGetBalancesOutput(BaseModel):
-    """
-    Output model for retrieving wallet balances.
-    """
+    """Output model for retrieving wallet balances."""
 
     res: list[WalletBalance] | None = Field(
         None, description="The wallet's balances along with token details."
@@ -41,79 +29,58 @@ class EnsoGetBalancesOutput(BaseModel):
 
 
 class EnsoGetWalletBalances(EnsoBaseTool):
-    """
-    This tool allows querying for first 20 token balances of a specific wallet
-    and blockchain network.
-
-    Attributes:
-        name (str): Name of the tool, specifically "enso_get_wallet_balances".
-        description (str): Comprehensive description of the tool's purpose and functionality.
-        args_schema (Type[BaseModel]): Schema for input arguments, specifying expected parameters.
-    """
+    """Retrieve token balances of a wallet on a specified blockchain network."""
 
     name: str = "enso_get_wallet_balances"
     description: str = (
         "Retrieve token balances of a wallet on a specified blockchain network."
     )
-    args_schema: Type[BaseModel] = EnsoGetBalancesInput
+    args_schema: type[BaseModel] = EnsoGetBalancesInput
 
     async def _arun(
         self,
-        chainId: int = default_chain_id,
-        **kwargs,
+        chainId: int | None = None,
+        **_: object,
     ) -> EnsoGetBalancesOutput:
-        """
-        Run the tool to get token balances of a wallet.
-
-        Args:
-            chainId (int): Chain ID of the blockchain network.
-
-        Returns:
-            EnsoGetBalancesOutput: The list of balances or an error message.
-        """
-        url = f"{base_url}/api/v1/wallet/balances"
-
         context = self.get_context()
+        resolved_chain_id = self.resolve_chain_id(context, chainId)
         api_token = self.get_api_token(context)
-        account = await self.get_account(context)
+        wallet_address = await self.get_wallet_address(context)
+
         headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {api_token}",
         }
 
-        params = EnsoGetBalancesInput(chainId=chainId).model_dump(exclude_none=True)
-        params["eoaAddress"] = account.address
+        params = EnsoGetBalancesInput(chainId=resolved_chain_id).model_dump(
+            exclude_none=True
+        )
+        params["eoaAddress"] = wallet_address
         params["useEoa"] = True
 
         async with httpx.AsyncClient() as client:
             try:
-                # Send the GET request
-                response = await client.get(url, headers=headers, params=params)
+                response = await client.get(
+                    f"{base_url}/api/v1/wallet/balances",
+                    headers=headers,
+                    params=params,
+                )
                 response.raise_for_status()
-
-                # Map the response JSON into the WalletBalance model
                 json_dict = response.json()[:20]
                 res = [WalletBalance(**item) for item in json_dict]
-
-                # Return the parsed response
                 return EnsoGetBalancesOutput(res=res)
             except httpx.RequestError as req_err:
                 raise ToolException("request error from Enso API") from req_err
             except httpx.HTTPStatusError as http_err:
                 raise ToolException("http error from Enso API") from http_err
-            except Exception as e:
-                raise ToolException(f"error from Enso API: {e}") from e
+            except Exception as exc:  # pragma: no cover - defensive
+                raise ToolException(f"error from Enso API: {exc}") from exc
 
 
 class EnsoGetApprovalsInput(BaseModel):
-    """
-    Input model for retrieving wallet approvals.
-    """
+    """Input model for retrieving wallet approvals."""
 
-    chainId: int = Field(
-        default_chain_id, description="Chain ID of the blockchain network"
-    )
-    fromAddress: str = Field(description="Address of the wallet")
+    chainId: int | None = Field(None, description="Chain ID of the blockchain network")
     routingStrategy: Literal["ensowallet", "router", "delegate"] | None = Field(
         None, description="Routing strategy to use"
     )
@@ -126,9 +93,7 @@ class WalletAllowance(BaseModel):
 
 
 class EnsoGetApprovalsOutput(BaseModel):
-    """
-    Output model for retrieving wallet approvals.
-    """
+    """Output model for retrieving wallet approvals."""
 
     res: list[WalletAllowance] | None = Field(
         None, description="Response containing the list of token approvals."
@@ -136,42 +101,24 @@ class EnsoGetApprovalsOutput(BaseModel):
 
 
 class EnsoGetWalletApprovals(EnsoBaseTool):
-    """
-    This tool allows querying for first 50 token spend approvals associated with a specific wallet
-    and blockchain network.
-
-    Attributes:
-        name (str): Name of the tool, specifically "enso_get_wallet_approvals".
-        description (str): Comprehensive description of the tool's purpose and functionality.
-        args_schema (Type[BaseModel]): Schema for input arguments, specifying expected parameters.
-    """
+    """Retrieve token spend approvals for a wallet on a specified blockchain network."""
 
     name: str = "enso_get_wallet_approvals"
     description: str = (
         "Retrieve token spend approvals for a wallet on a specified blockchain network."
     )
-    args_schema: Type[BaseModel] = EnsoGetApprovalsOutput
+    args_schema: type[BaseModel] = EnsoGetApprovalsInput
 
     async def _arun(
         self,
-        chainId: int = default_chain_id,
-        **kwargs,
+        chainId: int | None = None,
+        routingStrategy: Literal["ensowallet", "router", "delegate"] | None = None,
+        **_: object,
     ) -> EnsoGetApprovalsOutput:
-        """
-        Run the tool to get token approvals for a wallet.
-
-        Args:
-            chainId (int): Chain ID of the blockchain network.
-            **kwargs: optional kwargs for the tool with args schema defined in EnsoGetApprovalsInput.
-
-        Returns:
-            EnsoGetApprovalsOutput: The list of approvals or an error message.
-        """
-        url = f"{base_url}/api/v1/wallet/approvals"
-
         context = self.get_context()
+        resolved_chain_id = self.resolve_chain_id(context, chainId)
         api_token = self.get_api_token(context)
-        account = await self.get_account(context)
+        wallet_address = await self.get_wallet_address(context)
 
         headers = {
             "accept": "application/json",
@@ -179,26 +126,21 @@ class EnsoGetWalletApprovals(EnsoBaseTool):
         }
 
         params = EnsoGetApprovalsInput(
-            chainId=chainId,
-            fromAddress=account.address,
-        )
-
-        if kwargs.get("routingStrategy"):
-            params.routingStrategy = kwargs["routingStrategy"]
+            chainId=resolved_chain_id,
+            routingStrategy=routingStrategy,
+        ).model_dump(exclude_none=True)
+        params["fromAddress"] = wallet_address
 
         async with httpx.AsyncClient() as client:
             try:
-                # Send the GET request
                 response = await client.get(
-                    url, headers=headers, params=params.model_dump(exclude_none=True)
+                    f"{base_url}/api/v1/wallet/approvals",
+                    headers=headers,
+                    params=params,
                 )
                 response.raise_for_status()
-
-                # Map the response JSON into the ApprovalsResponse model
                 json_dict = response.json()[:50]
                 res = [WalletAllowance(**item) for item in json_dict]
-
-                # Return the parsed response
                 return EnsoGetApprovalsOutput(res=res)
             except httpx.RequestError as req_err:
                 raise ToolException(
@@ -208,29 +150,23 @@ class EnsoGetWalletApprovals(EnsoBaseTool):
                 raise ToolException(
                     f"http error from Enso API: {http_err}"
                 ) from http_err
-            except Exception as e:
-                raise ToolException(f"error from Enso API: {e}") from e
+            except Exception as exc:  # pragma: no cover - defensive
+                raise ToolException(f"error from Enso API: {exc}") from exc
 
 
 class EnsoWalletApproveInput(BaseModel):
-    """
-    Input model for approve the wallet.
-    """
+    """Input model for approving token spend for the wallet."""
 
     tokenAddress: str = Field(description="ERC20 token address of the token to approve")
     amount: int = Field(description="Amount of tokens to approve in wei")
-    chainId: int = Field(
-        default_chain_id, description="Chain ID of the blockchain network"
-    )
+    chainId: int | None = Field(None, description="Chain ID of the blockchain network")
     routingStrategy: Literal["ensowallet", "router", "delegate"] | None = Field(
         None, description="Routing strategy to use"
     )
 
 
 class EnsoWalletApproveOutput(BaseModel):
-    """
-    Output model for approve token for the wallet.
-    """
+    """Output model for approve token for the wallet."""
 
     gas: str | None = Field(None, description="The gas estimate for the transaction")
     token: str | None = Field(None, description="The token address to approve")
@@ -239,133 +175,82 @@ class EnsoWalletApproveOutput(BaseModel):
 
 
 class EnsoWalletApproveArtifact(BaseModel):
-    """
-    Output model for approve token for the wallet.
-    """
+    """Artifact returned after broadcasting an approval transaction."""
 
-    tx: object | None = Field(None, description="The tx object to use in `ethers`")
+    tx: object | None = Field(
+        None, description="The transaction object to use in `ethers`"
+    )
     txHash: str | None = Field(None, description="The transaction hash")
 
 
 class EnsoWalletApprove(EnsoBaseTool):
-    """
-    This tool is used specifically for broadcasting a ERC20 token spending approval transaction to the network.
-    It should only be used when the user explicitly requests to broadcast an approval transaction with a specific amount for a certain token.
-
-    **Example Usage:**
-
-    "Broadcast an approval transaction for 10 USDC to the wallet."
-
-    **Important:**
-    - This tool should be used with extreme caution.
-    - Approving token spending grants another account permission to spend your tokens.
-
-    Attributes:
-        name (str): Name of the tool, specifically "enso_wallet_approve".
-        description (str): Comprehensive description of the tool's purpose and functionality.
-        args_schema (Type[BaseModel]): Schema for input arguments, specifying expected parameters.
-    """
+    """Broadcast an ERC20 token spending approval transaction."""
 
     name: str = "enso_wallet_approve"
-    description: str = "This tool is used specifically for broadcasting a ERC20 token spending approval transaction to the network. It should only be used when the user explicitly requests to broadcast an approval transaction with a specific amount for a certain token."
-    args_schema: Type[BaseModel] = EnsoWalletApproveInput
+    description: str = (
+        "This tool is used specifically for broadcasting a ERC20 token spending approval transaction to the "
+        "network. It should only be used when the user explicitly requests to broadcast an approval transaction "
+        "with a specific amount for a certain token."
+    )
+    args_schema: type[BaseModel] = EnsoWalletApproveInput
     response_format: str = "content_and_artifact"
 
-    # def _run(
-    #     self,
-    #     tokenAddress: str,
-    #     amount: int,
-    #     chainId: int = default_chain_id,
-    #     **kwargs,
-    # ) -> Tuple[EnsoBroadcastWalletApproveOutput, EnsoBroadcastWalletApproveArtifact]:
-    #     """Run the tool to approve enso router for a wallet.
-
-    #     Returns:
-    #         Tuple[EnsoBroadcastWalletApproveOutput, EnsoBroadcastWalletApproveArtifact]: A structured output containing the result of token approval.
-
-    #     Raises:
-    #         Exception: If there's an error accessing the Enso API.
-    #     """
-    #     raise NotImplementedError("Use _arun instead")
-
     async def _arun(
         self,
         tokenAddress: str,
         amount: int,
-        chainId: int = default_chain_id,
-        **kwargs,
-    ) -> Tuple[EnsoWalletApproveOutput, EnsoWalletApproveArtifact]:
-        """
-        Run the tool to approve enso router for a wallet.
-
-        Args:
-            tokenAddress (str): ERC20 token address of the token to approve.
-            amount (int): Amount of tokens to approve in wei.
-            chainId (int): Chain ID of the blockchain network.
-            **kwargs: optional kwargs for the tool with args schema defined in EnsoGetApproveInput.
-
-        Returns:
-            Tuple[EnsoBroadcastWalletApproveOutput, EnsoBroadcastWalletApproveArtifact]: The list of approve transaction output or an error message.
-        """
-        url = f"{base_url}/api/v1/wallet/approve"
+        chainId: int | None = None,
+        routingStrategy: Literal["ensowallet", "router", "delegate"] | None = None,
+        **_: object,
+    ) -> tuple[EnsoWalletApproveOutput, EnsoWalletApproveArtifact]:
         context = self.get_context()
+        resolved_chain_id = self.resolve_chain_id(context, chainId)
         api_token = self.get_api_token(context)
-        account = await self.get_account(context)
+        wallet_address = await self.get_wallet_address(context)
 
         headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {api_token}",
         }
 
-        from_address = account.address
-
         params = EnsoWalletApproveInput(
             tokenAddress=tokenAddress,
             amount=amount,
-            chainId=chainId,
-        )
-
-        if kwargs.get("routingStrategy"):
-            params.routingStrategy = kwargs["routingStrategy"]
-
-        params = params.model_dump(exclude_none=True)
+            chainId=resolved_chain_id,
+            routingStrategy=routingStrategy,
+        ).model_dump(exclude_none=True)
+        params["fromAddress"] = wallet_address
 
-        params["fromAddress"] = from_address
-
-        with httpx.Client() as client:
+        async with httpx.AsyncClient() as client:
             try:
-                # Send the GET request
-                response = client.get(url, headers=headers, params=params)
+                response = await client.get(
+                    f"{base_url}/api/v1/wallet/approve",
+                    headers=headers,
+                    params=params,
+                )
                 response.raise_for_status()
 
-                # Map the response JSON into the WalletApproveTransaction model
                 json_dict = response.json()
                 content = EnsoWalletApproveOutput(**json_dict)
                 artifact = EnsoWalletApproveArtifact(**json_dict)
 
-                # Use the wallet provider to send the transaction
                 wallet_provider = await self.get_wallet_provider(context)
-
-                # Extract transaction data from the Enso API response
                 tx_data = json_dict.get("tx", {})
                 if tx_data:
-                    # Send the transaction using the wallet provider
                     tx_hash = wallet_provider.send_transaction(
                         {
                             "to": tx_data.get("to"),
                             "data": tx_data.get("data", "0x"),
                             "value": tx_data.get("value", 0),
+                            "from": wallet_address,
                         }
                     )
 
-                    # Wait for transaction confirmation
                     wallet_provider.wait_for_transaction_receipt(tx_hash)
                     artifact.txHash = tx_hash
                 else:
-                    # For now, return without executing the transaction if no tx data
                     artifact.txHash = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
-                # Return the parsed response
                 return (content, artifact)
             except httpx.RequestError as req_err:
                 raise ToolException(
@@ -375,5 +260,5 @@ class EnsoWalletApprove(EnsoBaseTool):
                 raise ToolException(
                     f"http error from Enso API: {http_err}"
                 ) from http_err
-            except Exception as e:
-                raise ToolException(f"error from Enso API: {e}") from e
+            except Exception as exc:  # pragma: no cover - defensive
+                raise ToolException(f"error from Enso API: {exc}") from exc

intentkit/skills/erc20/__init__.py

@@ -0,0 +1,50 @@
+"""ERC20 AgentKit skills."""
+
+from typing import TypedDict
+
+from coinbase_agentkit import erc20_action_provider
+
+from intentkit.models.agent import Agent
+from intentkit.skills.base import (
+    SkillConfig,
+    SkillState,
+    action_to_structured_tool,
+    get_agentkit_actions,
+)
+from intentkit.skills.erc20.base import ERC20BaseTool
+
+
+class SkillStates(TypedDict):
+    ERC20ActionProvider_get_balance: SkillState
+    ERC20ActionProvider_transfer: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for ERC20 skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: Config,
+    is_private: bool,
+    agent_id: str,
+    agent: Agent | None = None,
+    **_,
+) -> list[ERC20BaseTool]:
+    """Get all ERC20 skills."""
+
+    available_skills: list[str] = []
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        if state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    actions = await get_agentkit_actions(agent_id, [erc20_action_provider], agent=agent)
+    tools: list[ERC20BaseTool] = []
+    for skill in available_skills:
+        for action in actions:
+            if action.name.endswith(skill):
+                tools.append(action_to_structured_tool(action))
+    return tools

intentkit/skills/erc20/base.py

@@ -0,0 +1,11 @@
+"""ERC20 AgentKit skills base class."""
+
+from intentkit.skills.cdp.base import CDPBaseTool
+
+
+class ERC20BaseTool(CDPBaseTool):
+    """Base class for ERC20 tools."""
+
+    @property
+    def category(self) -> str:
+        return "erc20"

intentkit/skills/erc20/erc20.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128">
+  <rect width="128" height="128" fill="#1e88e5" rx="16" />
+  <circle cx="64" cy="64" r="40" fill="#bbdefb" />
+  <text x="50%" y="70%" font-family="Arial,Helvetica,sans-serif" font-size="48" fill="#0d47a1" font-weight="700" text-anchor="middle">20</text>
+</svg>

intentkit/skills/erc20/schema.json

@@ -0,0 +1,74 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "ERC20",
+  "description": "ERC20 token balance and transfer actions via Coinbase AgentKit",
+  "x-icon": "https://ai.service.crestal.dev/skills/erc20/erc20.svg",
+  "x-tags": [
+    "Crypto",
+    "DeFi"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "ERC20ActionProvider_get_balance": {
+          "type": "string",
+          "title": "Get ERC20 Balance",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "State for ERC20ActionProvider_get_balance",
+          "default": "disabled"
+        },
+        "ERC20ActionProvider_transfer": {
+          "type": "string",
+          "title": "Transfer ERC20",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "State for ERC20ActionProvider_transfer",
+          "default": "disabled"
+        }
+      },
+      "description": "States for each ERC20 skill (disabled, public, or private)"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Who provides the API key",
+      "enum": [
+        "platform"
+      ],
+      "x-enum-title": [
+        "Nation Hosted"
+      ],
+      "default": "platform"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "additionalProperties": true
+}

intentkit/skills/erc721/__init__.py

@@ -0,0 +1,53 @@
+"""ERC721 AgentKit skills."""
+
+from typing import TypedDict
+
+from coinbase_agentkit import erc721_action_provider
+
+from intentkit.models.agent import Agent
+from intentkit.skills.base import (
+    SkillConfig,
+    SkillState,
+    action_to_structured_tool,
+    get_agentkit_actions,
+)
+from intentkit.skills.erc721.base import ERC721BaseTool
+
+
+class SkillStates(TypedDict):
+    Erc721ActionProvider_get_balance: SkillState
+    Erc721ActionProvider_mint: SkillState
+    Erc721ActionProvider_transfer: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for ERC721 skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: Config,
+    is_private: bool,
+    agent_id: str,
+    agent: Agent | None = None,
+    **_,
+) -> list[ERC721BaseTool]:
+    """Get all ERC721 skills."""
+
+    available_skills: list[str] = []
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        if state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    actions = await get_agentkit_actions(
+        agent_id, [erc721_action_provider], agent=agent
+    )
+    tools: list[ERC721BaseTool] = []
+    for skill in available_skills:
+        for action in actions:
+            if action.name.endswith(skill):
+                tools.append(action_to_structured_tool(action))
+    return tools

intentkit/skills/erc721/base.py

@@ -0,0 +1,11 @@
+"""ERC721 AgentKit skills base class."""
+
+from intentkit.skills.cdp.base import CDPBaseTool
+
+
+class ERC721BaseTool(CDPBaseTool):
+    """Base class for ERC721 tools."""
+
+    @property
+    def category(self) -> str:
+        return "erc721"

intentkit/skills/erc721/erc721.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128">
+  <rect width="128" height="128" fill="#6a1b9a" rx="16" />
+  <polygon points="64,24 100,64 64,104 28,64" fill="#ce93d8" />
+  <text x="50%" y="72%" font-family="Arial,Helvetica,sans-serif" font-size="40" fill="#4a148c" font-weight="700" text-anchor="middle">721</text>
+</svg>