intentkit 0.7.5.dev17__py3-none-any.whl → 0.7.5.dev19__py3-none-any.whl

intentkit/core/node.py

@@ -81,10 +81,10 @@ class PreModelNode(RunnableCallable):
         self.func_accepts_config = True
 
     def _parse_input(
-        self, input: AgentState
+        self, state: AgentState
     ) -> tuple[list[AnyMessage], dict[str, Any]]:
-        messages = input.get("messages")
-        context = input.get("context", {})
+        messages = state.get("messages")
+        context = state.get("context", {})
         if messages is None or not isinstance(messages, list) or len(messages) == 0:
             raise ValueError("Missing required field `messages` in the input.")
         return messages, context
@@ -107,13 +107,13 @@ class PreModelNode(RunnableCallable):
     def _func(self, AgentState) -> dict[str, Any]:
         raise NotImplementedError("Not implemented yet")
 
-    async def _afunc(self, input: AgentState) -> dict[str, Any]:
-        messages, context = self._parse_input(input)
+    async def _afunc(self, state: AgentState) -> dict[str, Any]:
+        messages, context = self._parse_input(state)
         try:
             _validate_chat_history(messages)
         except ValueError as e:
             logger.error(f"Invalid chat history: {e}")
-            logger.info(input)
+            logger.info(state)
             # delete all messages
             return {"messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]}
         if self.short_term_memory_strategy == "trim":
@@ -162,7 +162,7 @@ class PreModelNode(RunnableCallable):
                 return self._prepare_state_update(context, summarization_result)
             except ValueError as e:
                 logger.error(f"Invalid chat history: {e}")
-                logger.info(input)
+                logger.info(state)
                 # delete all messages
                 return {"messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]}
         raise ValueError(
@@ -175,15 +175,15 @@ class PostModelNode(RunnableCallable):
         super().__init__(self._func, self._afunc, name="post_model_node", trace=False)
         self.func_accepts_config = True
 
-    def _func(self, input: AgentState) -> dict[str, Any]:
+    def _func(self, state: AgentState) -> dict[str, Any]:
         raise NotImplementedError("Not implemented yet")
 
-    async def _afunc(self, input: AgentState) -> dict[str, Any]:
+    async def _afunc(self, state: AgentState) -> dict[str, Any]:
         runtime = get_runtime(AgentContext)
         context = runtime.context
-        logger.debug(f"Running PostModelNode, input: {input}, context: {context}")
+        logger.debug(f"Running PostModelNode, input: {state}, context: {context}")
         state_update = {}
-        messages = input.get("messages")
+        messages = state.get("messages")
         if messages is None or not isinstance(messages, list) or len(messages) == 0:
             raise ValueError("Missing required field `messages` in the input.")
         payer = context.payer

intentkit/models/llm.py

@@ -12,7 +12,7 @@ from intentkit.models.base import Base
 from intentkit.models.db import get_session
 from intentkit.models.redis import get_redis
 from intentkit.utils.error import IntentKitLookUpError
-from langchain_core.language_models import LanguageModelLike
+from langchain.chat_models.base import BaseChatModel
 from pydantic import BaseModel, ConfigDict, Field
 from sqlalchemy import Boolean, Column, DateTime, Integer, Numeric, String, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -344,7 +344,7 @@ class LLMModel(BaseModel):
         return model_info
 
     # This will be implemented by subclasses to return the appropriate LLM instance
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, config: Any) -> BaseChatModel:
         """Create and return the LLM instance based on the configuration."""
         raise NotImplementedError("Subclasses must implement create_instance")
 
@@ -362,7 +362,7 @@ class LLMModel(BaseModel):
 class OpenAILLM(LLMModel):
     """OpenAI LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, config: Any) -> BaseChatModel:
         """Create and return a ChatOpenAI instance."""
         from langchain_openai import ChatOpenAI
 
@@ -398,7 +398,7 @@ class OpenAILLM(LLMModel):
 class DeepseekLLM(LLMModel):
     """Deepseek LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, config: Any) -> BaseChatModel:
         """Create and return a ChatDeepseek instance."""
 
         from langchain_deepseek import ChatDeepSeek
@@ -431,7 +431,7 @@ class DeepseekLLM(LLMModel):
 class XAILLM(LLMModel):
     """XAI (Grok) LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, config: Any) -> BaseChatModel:
         """Create and return a ChatXAI instance."""
 
         from langchain_xai import ChatXAI
@@ -463,7 +463,7 @@ class XAILLM(LLMModel):
 class EternalLLM(LLMModel):
     """Eternal AI LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, config: Any) -> BaseChatModel:
         """Create and return a ChatOpenAI instance configured for Eternal AI."""
         from langchain_openai import ChatOpenAI
 
@@ -495,7 +495,7 @@ class EternalLLM(LLMModel):
 class ReigentLLM(LLMModel):
     """Reigent LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, config: Any) -> BaseChatModel:
         """Create and return a ChatOpenAI instance configured for Reigent."""
         from langchain_openai import ChatOpenAI
 
@@ -517,7 +517,7 @@ class ReigentLLM(LLMModel):
 class VeniceLLM(LLMModel):
     """Venice LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, config: Any) -> BaseChatModel:
         """Create and return a ChatOpenAI instance configured for Venice."""
         from langchain_openai import ChatOpenAI
 

intentkit/skills/enso/__init__.py

@@ -36,7 +36,7 @@ class Config(SkillConfig):
 
     states: SkillStates
     api_token: NotRequired[str]
-    main_tokens: List[str]
+    main_tokens: NotRequired[List[str]]
 
 
 async def get_skills(

intentkit/skills/enso/base.py

@@ -1,6 +1,6 @@
+from decimal import Decimal
 from typing import Optional, Type
 
-from cdp import EvmServerAccount
 from coinbase_agentkit import CdpEvmWalletProvider
 from langchain.tools.base import ToolException
 from pydantic import BaseModel, Field
@@ -9,10 +9,9 @@ from intentkit.abstracts.graph import AgentContext
 from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.clients import CdpClient, get_cdp_client
 from intentkit.skills.base import IntentKitSkill
-from intentkit.utils.chain import ChainProvider, NetworkId
+from intentkit.utils.chain import ChainProvider, Network, network_to_id
 
 base_url = "https://api.enso.finance"
-default_chain_id = int(NetworkId.BaseMainnet)
 
 
 class EnsoBaseTool(IntentKitSkill):
@@ -25,18 +24,6 @@ class EnsoBaseTool(IntentKitSkill):
         description="The skill store for persisting data"
     )
 
-    async def get_account(self, context: AgentContext) -> Optional[EvmServerAccount]:
-        """Get the account object from the CDP client.
-
-        Args:
-            context: The skill context containing agent information.
-
-        Returns:
-            Optional[EvmServerAccount]: The account object if available.
-        """
-        client: CdpClient = await get_cdp_client(context.agent.id, self.skill_store)
-        return await client.get_account()
-
     async def get_wallet_provider(
         self, context: AgentContext
     ) -> Optional[CdpEvmWalletProvider]:
@@ -51,6 +38,13 @@ class EnsoBaseTool(IntentKitSkill):
         client: CdpClient = await get_cdp_client(context.agent.id, self.skill_store)
         return await client.get_wallet_provider()
 
+    async def get_wallet_address(self, context: AgentContext) -> str:
+        client: CdpClient = await get_cdp_client(context.agent.id, self.skill_store)
+        provider_config = await client.get_provider_config()
+        if not provider_config.address:
+            raise ToolException("wallet address not found for agent")
+        return provider_config.address
+
     def get_chain_provider(self, context: AgentContext) -> Optional[ChainProvider]:
         return self.skill_store.get_system_config("chain_provider")
 
@@ -60,8 +54,7 @@ class EnsoBaseTool(IntentKitSkill):
             return skill_config["main_tokens"]
         return []
 
-    def get_api_key(self) -> str:
-        context = self.get_context()
+    def get_api_token(self, context: AgentContext) -> str:
         skill_config = context.agent.skill_config(self.category)
         api_key_provider = skill_config.get("api_key_provider")
         if api_key_provider == "platform":
@@ -74,6 +67,40 @@ class EnsoBaseTool(IntentKitSkill):
                 f"Invalid API key provider: {api_key_provider}, or no api_token in config"
             )
 
+    def resolve_chain_id(
+        self, context: AgentContext, chain_id: Optional[int] = None
+    ) -> int:
+        if chain_id:
+            return chain_id
+
+        agent = context.agent
+        try:
+            network = Network(agent.network_id)
+        except ValueError as exc:  # pragma: no cover - defensive
+            raise ToolException(
+                f"Unsupported network configured for agent: {agent.network_id}"
+            ) from exc
+
+        network_id = network_to_id.get(network)
+        if network_id is None:
+            raise ToolException(
+                f"Unable to determine chain id for network: {agent.network_id}"
+            )
+        return int(network_id)
+
     @property
     def category(self) -> str:
         return "enso"
+
+
+def format_amount_with_decimals(
+    amount: object, decimals: Optional[int]
+) -> Optional[str]:
+    if amount is None or decimals is None:
+        return None
+
+    try:
+        value = Decimal(str(amount)) / (Decimal(10) ** decimals)
+        return format(value, "f")
+    except Exception:  # pragma: no cover - defensive
+        return None

intentkit/skills/enso/best_yield.py

@@ -4,14 +4,7 @@ import httpx
 from langchain.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.skills.enso.base import (
-    EnsoBaseTool,
-    base_url,
-)
-from intentkit.utils.chain import NetworkId
-
-# Chain ID for Base Mainnet
-BASE_CHAIN_ID = int(NetworkId.BaseMainnet)
+from intentkit.skills.enso.base import EnsoBaseTool, base_url
 
 
 class EnsoGetBestYieldInput(BaseModel):
@@ -21,9 +14,9 @@ class EnsoGetBestYieldInput(BaseModel):
         "USDC",
         description="Symbol of the token to find the best yield for (e.g., 'USDC', 'ETH', 'USDT')",
     )
-    chain_id: int = Field(
-        BASE_CHAIN_ID,
-        description="The blockchain chain ID. Default is Base Mainnet (8453)",
+    chain_id: int | None = Field(
+        None,
+        description="The blockchain chain ID. Defaults to the agent's configured network.",
     )
     top_n: int = Field(
         5,
@@ -80,7 +73,7 @@ class EnsoGetBestYield(EnsoBaseTool):
     async def _arun(
         self,
         token_symbol: str = "USDC",
-        chain_id: int = BASE_CHAIN_ID,
+        chain_id: int | None = None,
         top_n: int = 5,
         **kwargs,
     ) -> EnsoGetBestYieldOutput:
@@ -89,7 +82,7 @@ class EnsoGetBestYield(EnsoBaseTool):
 
         Args:
             token_symbol (str): Symbol of the token to find the best yield for (default: USDC)
-            chain_id (int): The chain id of the network (default: Base Mainnet)
+            chain_id (int | None): The chain id of the network. Defaults to the agent's configured network.
             top_n (int): Number of top yield options to return
 
         Returns:
@@ -99,16 +92,17 @@ class EnsoGetBestYield(EnsoBaseTool):
             ToolException: If there's an error accessing the Enso API.
         """
         context = self.get_context()
+        resolved_chain_id = self.resolve_chain_id(context, chain_id)
         api_token = self.get_api_token(context)
 
         if not api_token:
             raise ToolException("No API token found for Enso Finance")
 
         # Get the chain name for the given chain ID
-        chain_name = await self._get_chain_name(api_token, chain_id)
+        chain_name = await self._get_chain_name(api_token, resolved_chain_id)
 
         # Get all protocols on the specified chain
-        protocols = await self._get_protocols(api_token, chain_id)
+        protocols = await self._get_protocols(api_token, resolved_chain_id)
 
         # Collect all yield options from all protocols
         all_yield_options = []
@@ -119,7 +113,7 @@ class EnsoGetBestYield(EnsoBaseTool):
 
             # Get yield-bearing tokens for this protocol
             tokens = await self._get_protocol_tokens(
-                api_token, chain_id, protocol_slug, token_symbol
+                api_token, resolved_chain_id, protocol_slug, token_symbol
             )
 
             # Process tokens to extract yield options
@@ -170,7 +164,7 @@ class EnsoGetBestYield(EnsoBaseTool):
         return EnsoGetBestYieldOutput(
             best_options=top_options,
             token_symbol=token_symbol,
-            chain_id=chain_id,
+            chain_id=resolved_chain_id,
             chain_name=chain_name,
         )
 

intentkit/skills/enso/networks.py

@@ -7,8 +7,6 @@ from pydantic import BaseModel, Field
 
 from .base import EnsoBaseTool, base_url
 
-logger = logging.getLogger(__name__)
-
 
 class EnsoGetNetworksInput(BaseModel):
     """
@@ -38,6 +36,9 @@ class EnsoGetNetworksOutput(BaseModel):
     )
 
 
+logger = logging.getLogger(__name__)
+
+
 class EnsoGetNetworks(EnsoBaseTool):
     """
     Tool for retrieving networks and their corresponding chainId, the output should be kept.

intentkit/skills/enso/prices.py

@@ -4,13 +4,11 @@ import httpx
 from langchain.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 EnsoGetPricesInput(BaseModel):
-    chainId: int = Field(
-        default_chain_id, description="Blockchain chain ID of the token"
-    )
+    chainId: int | None = Field(None, description="Blockchain chain ID of the token")
     address: str = Field(
         "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
         description="Contract address of the token",
@@ -43,22 +41,21 @@ class EnsoGetPrices(EnsoBaseTool):
     async def _arun(
         self,
         address: str,
-        chainId: int = default_chain_id,
+        chainId: int | None = None,
         **kwargs,
     ) -> EnsoGetPricesOutput:
         """
         Asynchronous function to request the token price from the API.
 
         Args:
-            chainId (int): The blockchain's chain ID.
+            chainId (int | None): The blockchain's chain ID. Defaults to the agent's configured network.
             address (str): Contract address of the token.
 
         Returns:
             EnsoGetPricesOutput: Token price response or error message.
         """
-        url = f"{base_url}/api/v1/prices/{str(chainId)}/{address}"
-
         context = self.get_context()
+        resolved_chain_id = self.resolve_chain_id(context, chainId)
         api_token = self.get_api_token(context)
 
         headers = {
@@ -68,7 +65,10 @@ class EnsoGetPrices(EnsoBaseTool):
 
         async with httpx.AsyncClient() as client:
             try:
-                response = await client.get(url, headers=headers)
+                response = await client.get(
+                    f"{base_url}/api/v1/prices/{str(resolved_chain_id)}/{address}",
+                    headers=headers,
+                )
                 response.raise_for_status()
                 json_dict = response.json()
 

intentkit/skills/enso/route.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel, Field
 
 from intentkit.skills.enso.networks import EnsoGetNetworks
 
-from .base import EnsoBaseTool, base_url, default_chain_id
+from .base import EnsoBaseTool, base_url, format_amount_with_decimals
 
 
 class EnsoRouteShortcutInput(BaseModel):
@@ -18,9 +18,9 @@ class EnsoRouteShortcutInput(BaseModel):
         False,
         description="Whether to broadcast the transaction or not, this is false by default.",
     )
-    chainId: int = Field(
-        default_chain_id,
-        description="(Optional) Chain ID of the network to execute the transaction on. the default value is the chain_id extracted from networks according to tokenIn and tokenOut",
+    chainId: int | None = Field(
+        None,
+        description="(Optional) Chain ID of the network to execute the transaction on. Defaults to the agent's configured network.",
     )
     amountIn: list[int] = Field(
         description="Amount of tokenIn to swap in wei, you should multiply user's requested value by token decimals."
@@ -162,7 +162,7 @@ class EnsoRouteShortcut(EnsoBaseTool):
         amountIn: list[int],
         tokenIn: list[str],
         tokenOut: list[str],
-        chainId: int = default_chain_id,
+        chainId: int | None = None,
         broadcast_requested: bool = False,
         **kwargs,
     ) -> EnsoRouteShortcutOutput:
@@ -173,7 +173,7 @@ class EnsoRouteShortcut(EnsoBaseTool):
             amountIn (list[int]): Amount of tokenIn to swap in wei, you should multiply user's requested value by token decimals.
             tokenIn (list[str]): Ethereum address of the token to swap or enter into a position from (For ETH, use 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee).
             tokenOut (list[str]): Ethereum address of the token to swap or enter into a position to (For ETH, use 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee).
-            chainId (int): The chain id of the network to be used for swap, deposit and routing.
+            chainId (int | None): The chain id of the network to be used for swap, deposit and routing. Defaults to the agent's configured network.
             broadcast_requested (bool): User should ask for broadcasting the transaction explicitly, otherwise it is always false.
 
         Returns:
@@ -182,8 +182,9 @@ class EnsoRouteShortcut(EnsoBaseTool):
 
         context = self.get_context()
         agent_id = context.agent_id
+        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)
 
         async with httpx.AsyncClient() as client:
             try:
@@ -193,9 +194,10 @@ class EnsoRouteShortcut(EnsoBaseTool):
                 )
 
                 if networks:
+                    resolved_key = str(resolved_chain_id)
                     network_name = (
-                        networks.get(str(chainId)).get("name")
-                        if networks.get(str(chainId))
+                        networks.get(resolved_key).get("name")
+                        if networks.get(resolved_key)
                         else None
                     )
                 if network_name is None:
@@ -204,12 +206,12 @@ class EnsoRouteShortcut(EnsoBaseTool):
                     ).arun()
 
                     for network in networks.res:
-                        if network.id == chainId:
+                        if network.id == resolved_chain_id:
                             network_name = network.name
 
                 if not network_name:
                     raise ToolException(
-                        f"network name not found for chainId: {chainId}"
+                        f"network name not found for chainId: {resolved_chain_id}"
                     )
 
                 headers = {
@@ -242,13 +244,13 @@ class EnsoRouteShortcut(EnsoBaseTool):
 
                 # Prepare query parameters
                 params = EnsoRouteShortcutInput(
-                    chainId=chainId,
+                    chainId=resolved_chain_id,
                     amountIn=amountIn,
                     tokenIn=tokenIn,
                     tokenOut=tokenOut,
                 ).model_dump(exclude_none=True)
 
-                params["fromAddress"] = account.address
+                params["fromAddress"] = wallet_address
 
                 response = await client.get(url, headers=headers, params=params)
                 response.raise_for_status()  # Raise HTTPError for non-2xx responses
@@ -256,10 +258,12 @@ class EnsoRouteShortcut(EnsoBaseTool):
 
                 res = EnsoRouteShortcutOutput(**json_dict)
                 res.network = network_name
-
-                res.amountOut = str(
-                    float(res.amountOut) / 10 ** token_decimals[tokenOut[0]]
+                decimals = token_decimals.get(tokenOut[0])
+                amount_out = format_amount_with_decimals(
+                    json_dict.get("amountOut"), decimals
                 )
+                if amount_out is not None:
+                    res.amountOut = amount_out
 
                 if broadcast_requested:
                     # Use the wallet provider to send the transaction
@@ -269,13 +273,13 @@ class EnsoRouteShortcut(EnsoBaseTool):
                     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),
-                            }
-                        )
+                        tx_params = {
+                            "to": tx_data.get("to"),
+                            "data": tx_data.get("data", "0x"),
+                            "value": tx_data.get("value", 0),
+                            "from": wallet_address,
+                        }
+                        tx_hash = wallet_provider.send_transaction(tx_params)
 
                         # Wait for transaction confirmation
                         wallet_provider.wait_for_transaction_receipt(tx_hash)

intentkit/skills/enso/tokens.py

@@ -4,11 +4,7 @@ import httpx
 from langchain.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.skills.enso.base import (
-    EnsoBaseTool,
-    base_url,
-    default_chain_id,
-)
+from intentkit.skills.enso.base import EnsoBaseTool, base_url
 
 # Actual Enso output types
 # class UnderlyingToken(BaseModel):
@@ -50,9 +46,9 @@ from intentkit.skills.enso.base import (
 
 
 class EnsoGetTokensInput(BaseModel):
-    chainId: int = Field(
-        default_chain_id,
-        description="The blockchain chain ID",
+    chainId: int | None = Field(
+        None,
+        description="The blockchain chain ID. Defaults to the agent's configured network.",
     )
     protocolSlug: str | None = Field(
         None,
@@ -110,7 +106,10 @@ class TokenResponseCompact(BaseModel):
 
 
 class EnsoGetTokensOutput(BaseModel):
-    res: list[TokenResponseCompact] | None
+    res: list[TokenResponseCompact] = Field(
+        default_factory=list,
+        description="List of token information entries",
+    )
 
 
 class EnsoGetTokens(EnsoBaseTool):
@@ -138,7 +137,7 @@ class EnsoGetTokens(EnsoBaseTool):
 
     async def _arun(
         self,
-        chainId: int = default_chain_id,
+        chainId: int | None = None,
         protocolSlug: str | None = None,
         **kwargs,
     ) -> EnsoGetTokensOutput:
@@ -156,15 +155,17 @@ class EnsoGetTokens(EnsoBaseTool):
 
         context = self.get_context()
         agent_id = context.agent_id
+        resolved_chain_id = self.resolve_chain_id(context, chainId)
         api_token = self.get_api_token(context)
         main_tokens = self.get_main_tokens(context)
+        main_tokens_upper = {token.upper() for token in main_tokens}
         headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {api_token}",
         }
 
         params = EnsoGetTokensInput(
-            chainId=chainId,
+            chainId=resolved_chain_id,
             protocolSlug=protocolSlug,
         ).model_dump(exclude_none=True)
 
@@ -186,19 +187,21 @@ class EnsoGetTokens(EnsoBaseTool):
                     token_decimals = {}
 
                 # filter the main tokens from config or the ones that have apy assigned.
-                res = EnsoGetTokensOutput(res=list[TokenResponseCompact]())
-                for item in json_dict["data"]:
-                    main_tokens = [item.upper() for item in main_tokens]
-                    if item.get("apy") or (item.get("symbol").upper() in main_tokens):
+                res = EnsoGetTokensOutput()
+                for item in json_dict.get("data", []):
+                    symbol = item.get("symbol", "").upper()
+                    has_apy = bool(item.get("apy"))
+                    if has_apy or symbol in main_tokens_upper:
                         token_response = TokenResponseCompact(**item)
                         res.res.append(token_response)
-                        token_decimals[token_response.address] = token_response.decimals
-                        if (
-                            token_response.underlyingTokens
-                            and len(token_response.underlyingTokens) > 0
-                        ):
+                        if token_response.address:
+                            token_decimals[token_response.address] = (
+                                token_response.decimals
+                            )
+                        if token_response.underlyingTokens:
                             for u_token in token_response.underlyingTokens:
-                                token_decimals[u_token.address] = u_token.decimals
+                                if u_token.address:
+                                    token_decimals[u_token.address] = u_token.decimals
 
                 await self.skill_store.save_agent_skill_data(
                     agent_id,