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

intentkit/__init__.py

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

intentkit/config/config.py

@@ -1,5 +1,3 @@
-# app/config.py
-import asyncio
 import json
 import logging
 import os
@@ -11,9 +9,6 @@ from intentkit.utils.logging import setup_logging
 from intentkit.utils.s3 import init_s3
 from intentkit.utils.slack_alert import init_slack
 
-# hack for cdp bug
-asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
-
 # Load environment variables from .env file
 load_dotenv()
 

intentkit/core/engine.py

@@ -21,6 +21,7 @@ from typing import Optional, Tuple
 
 import sqlalchemy
 from epyxid import XID
+from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import (
     BaseMessage,
     HumanMessage,
@@ -29,6 +30,7 @@ from langchain_core.tools import BaseTool
 from langgraph.errors import GraphRecursionError
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.prebuilt import create_react_agent
+from langgraph.runtime import Runtime
 from sqlalchemy import func, update
 from sqlalchemy.exc import SQLAlchemyError
 
@@ -70,8 +72,8 @@ _agents_updated: dict[str, datetime] = {}
 _private_agents_updated: dict[str, datetime] = {}
 
 
-async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateGraph:
-    """Create an AI agent with specified configuration and tools.
+async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph:
+    """Build an AI agent with specified configuration and tools.
 
     This function:
     1. Initializes LLM with specified model
@@ -81,13 +83,12 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
 
     Args:
         agent (Agent): Agent configuration object
+        agent_data (AgentData): Agent data object
         is_private (bool, optional): Flag indicating whether the agent is private. Defaults to False.
-        has_search (bool, optional): Flag indicating whether to include search tools. Defaults to False.
 
     Returns:
         CompiledStateGraph: Initialized LangChain agent
     """
-    agent_data = await AgentData.get(agent.id)
 
     # Create the LLM model instance
     llm_model = await create_llm_model(
@@ -108,6 +109,7 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
 
     # ==== Load skills
     tools: list[BaseTool | dict] = []
+    private_tools: list[BaseTool | dict] = []
 
     if agent.skills:
         for k, v in agent.skills.items():
@@ -116,11 +118,18 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
             try:
                 skill_module = importlib.import_module(f"intentkit.skills.{k}")
                 if hasattr(skill_module, "get_skills"):
+                    # all
                     skill_tools = await skill_module.get_skills(
-                        v, is_private, agent_store, agent_id=agent.id
+                        v, False, agent_store, agent_id=agent.id
                     )
                     if skill_tools and len(skill_tools) > 0:
                         tools.extend(skill_tools)
+                    # private
+                    skill_private_tools = await skill_module.get_skills(
+                        v, True, agent_store, agent_id=agent.id
+                    )
+                    if skill_private_tools and len(skill_private_tools) > 0:
+                        private_tools.extend(skill_private_tools)
                 else:
                     logger.error(f"Skill {k} does not have get_skills function")
             except ImportError as e:
@@ -128,23 +137,33 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
 
     # filter the duplicate tools
     tools = list({tool.name: tool for tool in tools}.values())
+    private_tools = list({tool.name: tool for tool in private_tools}.values())
 
     # Add search tools if requested
     if (
-        llm_model.info.provider == LLMProvider.OPENAI
-        and llm_model.info.supports_search
-        and not agent.model.startswith(
-            "gpt-5"
-        )  # tmp disable gpt-5 search since package bugs
+        llm_model.info.provider == LLMProvider.OPENAI and llm_model.info.supports_search
+        # and not agent.model.startswith(
+        #     "gpt-5"
+        # )  # tmp disable gpt-5 search since package bugs
     ):
         tools.append({"type": "web_search_preview"})
+        private_tools.append({"type": "web_search_preview"})
 
     # Create the formatted_prompt function using the refactored prompt module
     formatted_prompt = create_formatted_prompt_function(agent, agent_data)
 
+    # bind tools to llm
+    def select_model(
+        state: AgentState, runtime: Runtime[AgentContext]
+    ) -> BaseChatModel:
+        context = runtime.context
+        if context.is_private:
+            return llm.bind_tools(private_tools)
+        return llm.bind_tools(tools)
+
     for tool in tools:
         logger.info(
-            f"[{agent.id}{'-private' if is_private else ''}] loaded tool: {tool.name if isinstance(tool, BaseTool) else tool}"
+            f"[{agent.id}] loaded tool: {tool.name if isinstance(tool, BaseTool) else tool}"
         )
 
     # Pre model hook
@@ -157,7 +176,7 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
 
     # Create ReAct Agent using the LLM and CDP Agentkit tools.
     executor = create_react_agent(
-        model=llm,
+        model=select_model,
         tools=tools,
         prompt=formatted_prompt,
         pre_model_hook=pre_model_hook,
@@ -172,7 +191,23 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
     return executor
 
 
-async def initialize_agent(aid, is_private=False):
+async def create_agent(agent: Agent) -> CompiledStateGraph:
+    """Create an AI agent with specified configuration and tools.
+
+    This function maintains backward compatibility by calling build_agent internally.
+
+    Args:
+        agent (Agent): Agent configuration object
+        is_private (bool, optional): Flag indicating whether the agent is private. Defaults to False.
+
+    Returns:
+        CompiledStateGraph: Initialized LangChain agent
+    """
+    agent_data = await AgentData.get(agent.id)
+    return await build_agent(agent, agent_data)
+
+
+async def initialize_agent(aid):
     """Initialize an AI agent with specified configuration and tools.
 
     This function:
@@ -198,47 +233,34 @@ async def initialize_agent(aid, is_private=False):
         )
 
     # Create the agent using the new create_agent function
-    executor = await create_agent(agent, is_private)
+    executor = await create_agent(agent)
 
     # Cache the agent executor
-    if is_private:
-        _private_agents[aid] = executor
-        _private_agents_updated[aid] = agent.updated_at
-    else:
-        _agents[aid] = executor
-        _agents_updated[aid] = agent.updated_at
+    _agents[aid] = executor
+    _agents_updated[aid] = agent.deployed_at if agent.deployed_at else agent.updated_at
 
 
-async def agent_executor(
-    agent_id: str, is_private: bool
-) -> Tuple[CompiledStateGraph, float]:
+async def agent_executor(agent_id: str) -> Tuple[CompiledStateGraph, float]:
     start = time.perf_counter()
     agent = await Agent.get(agent_id)
     if not agent:
         raise IntentKitAPIError(
             status_code=404, key="AgentNotFound", message="Agent not found"
         )
-    agents = _private_agents if is_private else _agents
-    agents_updated = _private_agents_updated if is_private else _agents_updated
-
+    updated_at = agent.deployed_at if agent.deployed_at else agent.updated_at
     # Check if agent needs reinitialization due to updates
     needs_reinit = False
-    if agent_id in agents:
-        if (
-            agent_id not in agents_updated
-            or agent.updated_at != agents_updated[agent_id]
-        ):
+    if agent_id in _agents:
+        if agent_id not in _agents_updated or updated_at != _agents_updated[agent_id]:
             needs_reinit = True
-            logger.info(
-                f"Reinitializing agent {agent_id} due to updates, private mode: {is_private}"
-            )
+            logger.info(f"Reinitializing agent {agent_id} due to updates")
 
     # cold start or needs reinitialization
     cold_start_cost = 0.0
-    if (agent_id not in agents) or needs_reinit:
-        await initialize_agent(agent_id, is_private)
+    if (agent_id not in _agents) or needs_reinit:
+        await initialize_agent(agent_id)
         cold_start_cost = time.perf_counter() - start
-    return agents[agent_id], cold_start_cost
+    return _agents[agent_id], cold_start_cost
 
 
 async def stream_agent(message: ChatMessageCreate):
@@ -355,7 +377,7 @@ async def stream_agent(message: ChatMessageCreate):
     if input.user_id == agent.owner:
         is_private = True
 
-    executor, cold_start_cost = await agent_executor(input.agent_id, is_private)
+    executor, cold_start_cost = await agent_executor(input.agent_id)
     last = start + cold_start_cost
 
     # Extract images from attachments
@@ -889,10 +911,7 @@ async def clean_agent_memory(
 async def thread_stats(agent_id: str, chat_id: str) -> list[BaseMessage]:
     thread_id = f"{agent_id}-{chat_id}"
     stream_config = {"configurable": {"thread_id": thread_id}}
-    is_private = False
-    if chat_id.startswith("owner") or chat_id.startswith("autonomous"):
-        is_private = True
-    executor, _ = await agent_executor(agent_id, is_private)
+    executor, _ = await agent_executor(agent_id)
     snap = await executor.aget_state(stream_config)
     if snap.values and "messages" in snap.values:
         return snap.values["messages"]

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()