intentkit 0.8.11__py3-none-any.whl → 0.8.12__py3-none-any.whl

intentkit/core/agent.py

@@ -2,21 +2,19 @@ import logging
 import time
 from datetime import datetime, timedelta, timezone
 from decimal import Decimal
-from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple
+from typing import AsyncGenerator, Dict, Optional, Tuple
 
 from sqlalchemy import func, select, text, update
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.clients.cdp import get_wallet_provider
 from intentkit.config.config import config
 from intentkit.models.agent import (
     Agent,
-    AgentAutonomous,
     AgentCreate,
     AgentTable,
     AgentUpdate,
 )
-from intentkit.models.agent_data import AgentData, AgentQuota, AgentQuotaTable
+from intentkit.models.agent_data import AgentData, AgentQuotaTable
 from intentkit.models.credit import (
     CreditAccount,
     CreditEventTable,
@@ -25,12 +23,6 @@ from intentkit.models.credit import (
     UpstreamType,
 )
 from intentkit.models.db import get_session
-from intentkit.models.skill import (
-    AgentSkillData,
-    AgentSkillDataCreate,
-    ThreadSkillData,
-    ThreadSkillDataCreate,
-)
 from intentkit.utils.error import IntentKitAPIError
 from intentkit.utils.slack_alert import send_slack_message
 
@@ -492,182 +484,6 @@ async def agent_action_cost(agent_id: str) -> Dict[str, Decimal]:
         return result
 
 
-class AgentStore(SkillStoreABC):
-    """Implementation of skill data storage operations.
-
-    This class provides concrete implementations for storing and retrieving
-    skill-related data for both agents and threads.
-    """
-
-    @staticmethod
-    def get_system_config(key: str) -> Any:
-        # TODO: maybe need a whitelist here
-        if hasattr(config, key):
-            return getattr(config, key)
-        return None
-
-    @staticmethod
-    async def get_agent_config(agent_id: str) -> Optional[Agent]:
-        return await Agent.get(agent_id)
-
-    @staticmethod
-    async def get_agent_data(agent_id: str) -> AgentData:
-        return await AgentData.get(agent_id)
-
-    @staticmethod
-    async def set_agent_data(agent_id: str, data: Dict) -> AgentData:
-        return await AgentData.patch(agent_id, data)
-
-    @staticmethod
-    async def get_agent_quota(agent_id: str) -> AgentQuota:
-        return await AgentQuota.get(agent_id)
-
-    @staticmethod
-    async def get_agent_skill_data(
-        agent_id: str, skill: str, key: str
-    ) -> Optional[Dict[str, Any]]:
-        """Get skill data for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            skill: Name of the skill
-            key: Data key
-
-        Returns:
-            Dictionary containing the skill data if found, None otherwise
-        """
-        return await AgentSkillData.get(agent_id, skill, key)
-
-    @staticmethod
-    async def save_agent_skill_data(
-        agent_id: str, skill: str, key: str, data: Dict[str, Any]
-    ) -> None:
-        """Save or update skill data for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            skill: Name of the skill
-            key: Data key
-            data: JSON data to store
-        """
-        skill_data = AgentSkillDataCreate(
-            agent_id=agent_id,
-            skill=skill,
-            key=key,
-            data=data,
-        )
-        await skill_data.save()
-
-    @staticmethod
-    async def delete_agent_skill_data(agent_id: str, skill: str, key: str) -> None:
-        """Delete skill data for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            skill: Name of the skill
-            key: Data key
-        """
-        await AgentSkillData.delete(agent_id, skill, key)
-
-    @staticmethod
-    async def get_thread_skill_data(
-        thread_id: str, skill: str, key: str
-    ) -> Optional[Dict[str, Any]]:
-        """Get skill data for a thread.
-
-        Args:
-            thread_id: ID of the thread
-            skill: Name of the skill
-            key: Data key
-
-        Returns:
-            Dictionary containing the skill data if found, None otherwise
-        """
-        return await ThreadSkillData.get(thread_id, skill, key)
-
-    @staticmethod
-    async def save_thread_skill_data(
-        thread_id: str,
-        agent_id: str,
-        skill: str,
-        key: str,
-        data: Dict[str, Any],
-    ) -> None:
-        """Save or update skill data for a thread.
-
-        Args:
-            thread_id: ID of the thread
-            agent_id: ID of the agent that owns this thread
-            skill: Name of the skill
-            key: Data key
-            data: JSON data to store
-        """
-        skill_data = ThreadSkillDataCreate(
-            thread_id=thread_id,
-            agent_id=agent_id,
-            skill=skill,
-            key=key,
-            data=data,
-        )
-        await skill_data.save()
-
-    @staticmethod
-    async def list_autonomous_tasks(agent_id: str) -> List[AgentAutonomous]:
-        """List all autonomous tasks for an agent.
-
-        Args:
-            agent_id: ID of the agent
-
-        Returns:
-            List[AgentAutonomous]: List of autonomous task configurations
-        """
-        return await list_autonomous_tasks(agent_id)
-
-    @staticmethod
-    async def add_autonomous_task(
-        agent_id: str, task: AgentAutonomous
-    ) -> AgentAutonomous:
-        """Add a new autonomous task to an agent.
-
-        Args:
-            agent_id: ID of the agent
-            task: Autonomous task configuration
-
-        Returns:
-            AgentAutonomous: The created task
-        """
-        return await add_autonomous_task(agent_id, task)
-
-    @staticmethod
-    async def delete_autonomous_task(agent_id: str, task_id: str) -> None:
-        """Delete an autonomous task from an agent.
-
-        Args:
-            agent_id: ID of the agent
-            task_id: ID of the task to delete
-        """
-        await delete_autonomous_task(agent_id, task_id)
-
-    @staticmethod
-    async def update_autonomous_task(
-        agent_id: str, task_id: str, task_updates: dict
-    ) -> AgentAutonomous:
-        """Update an autonomous task for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            task_id: ID of the task to update
-            task_updates: Dictionary containing fields to update
-
-        Returns:
-            AgentAutonomous: The updated task
-        """
-        return await update_autonomous_task(agent_id, task_id, task_updates)
-
-
-agent_store = AgentStore()
-
-
 async def _iterate_agent_id_batches(
     batch_size: int = 100,
 ) -> AsyncGenerator[list[str], None]:
@@ -923,191 +739,3 @@ async def update_agents_statistics(
         total_updated,
         total_time,
     )
-
-
-async def list_autonomous_tasks(agent_id: str) -> List[AgentAutonomous]:
-    """
-    List all autonomous tasks for an agent.
-
-    Args:
-        agent_id: ID of the agent
-
-    Returns:
-        List[AgentAutonomous]: List of autonomous task configurations
-
-    Raises:
-        IntentKitAPIError: If agent is not found
-    """
-    agent = await Agent.get(agent_id)
-    if not agent:
-        raise IntentKitAPIError(
-            400, "AgentNotFound", f"Agent with ID {agent_id} does not exist."
-        )
-
-    if not agent.autonomous:
-        return []
-
-    return agent.autonomous
-
-
-async def add_autonomous_task(agent_id: str, task: AgentAutonomous) -> AgentAutonomous:
-    """
-    Add a new autonomous task to an agent.
-
-    Args:
-        agent_id: ID of the agent
-        task: Autonomous task configuration (id will be generated if not provided)
-
-    Returns:
-        AgentAutonomous: The created task with generated ID
-
-    Raises:
-        IntentKitAPIError: If agent is not found
-    """
-    agent = await Agent.get(agent_id)
-    if not agent:
-        raise IntentKitAPIError(
-            400, "AgentNotFound", f"Agent with ID {agent_id} does not exist."
-        )
-
-    # Get current autonomous tasks
-    current_tasks = agent.autonomous or []
-    if not isinstance(current_tasks, list):
-        current_tasks = []
-
-    # Add the new task
-    current_tasks.append(task)
-
-    # Convert all AgentAutonomous objects to dictionaries for JSON serialization
-    serializable_tasks = [task_item.model_dump() for task_item in current_tasks]
-
-    # Update the agent in the database
-    async with get_session() as session:
-        update_stmt = (
-            update(AgentTable)
-            .where(AgentTable.id == agent_id)
-            .values(autonomous=serializable_tasks)
-        )
-        await session.execute(update_stmt)
-        await session.commit()
-
-    logger.info(f"Added autonomous task {task.id} to agent {agent_id}")
-    return task
-
-
-async def delete_autonomous_task(agent_id: str, task_id: str) -> None:
-    """
-    Delete an autonomous task from an agent.
-
-    Args:
-        agent_id: ID of the agent
-        task_id: ID of the task to delete
-
-    Raises:
-        IntentKitAPIError: If agent is not found or task is not found
-    """
-    agent = await Agent.get(agent_id)
-    if not agent:
-        raise IntentKitAPIError(
-            400, "AgentNotFound", f"Agent with ID {agent_id} does not exist."
-        )
-
-    # Get current autonomous tasks
-    current_tasks = agent.autonomous or []
-    if not isinstance(current_tasks, list):
-        current_tasks = []
-
-    # Find and remove the task
-    task_found = False
-    updated_tasks = []
-    for task_data in current_tasks:
-        if task_data.id == task_id:
-            task_found = True
-            continue
-        updated_tasks.append(task_data)
-
-    if not task_found:
-        raise IntentKitAPIError(
-            404, "TaskNotFound", f"Autonomous task with ID {task_id} not found."
-        )
-
-    # Convert remaining AgentAutonomous objects to dictionaries for JSON serialization
-    serializable_tasks = [task_item.model_dump() for task_item in updated_tasks]
-
-    # Update the agent in the database
-    async with get_session() as session:
-        update_stmt = (
-            update(AgentTable)
-            .where(AgentTable.id == agent_id)
-            .values(autonomous=serializable_tasks)
-        )
-        await session.execute(update_stmt)
-        await session.commit()
-
-    logger.info(f"Deleted autonomous task {task_id} from agent {agent_id}")
-
-
-async def update_autonomous_task(
-    agent_id: str, task_id: str, task_updates: dict
-) -> AgentAutonomous:
-    """
-    Update an autonomous task for an agent.
-
-    Args:
-        agent_id: ID of the agent
-        task_id: ID of the task to update
-        task_updates: Dictionary containing fields to update
-
-    Returns:
-        AgentAutonomous: The updated task
-
-    Raises:
-        IntentKitAPIError: If agent is not found or task is not found
-    """
-    agent = await Agent.get(agent_id)
-    if not agent:
-        raise IntentKitAPIError(
-            400, "AgentNotFound", f"Agent with ID {agent_id} does not exist."
-        )
-
-    # Get current autonomous tasks
-    current_tasks: List[AgentAutonomous] = agent.autonomous or []
-
-    # Find and update the task
-    task_found = False
-    updated_tasks: List[AgentAutonomous] = []
-    updated_task = None
-
-    for task_data in current_tasks:
-        if task_data.id == task_id:
-            task_found = True
-            # Create a dictionary with current task data
-            task_dict = task_data.model_dump()
-            # Update with provided fields
-            task_dict.update(task_updates)
-            # Create new AgentAutonomous instance
-            updated_task = AgentAutonomous.model_validate(task_dict)
-            updated_tasks.append(updated_task)
-        else:
-            updated_tasks.append(task_data)
-
-    if not task_found:
-        raise IntentKitAPIError(
-            404, "TaskNotFound", f"Autonomous task with ID {task_id} not found."
-        )
-
-    # Convert all AgentAutonomous objects to dictionaries for JSON serialization
-    serializable_tasks = [task_item.model_dump() for task_item in updated_tasks]
-
-    # Update the agent in the database
-    async with get_session() as session:
-        update_stmt = (
-            update(AgentTable)
-            .where(AgentTable.id == agent_id)
-            .values(autonomous=serializable_tasks)
-        )
-        await session.execute(update_stmt)
-        await session.commit()
-
-    logger.info(f"Updated autonomous task {task_id} for agent {agent_id}")
-    return updated_task

intentkit/core/asset.py

@@ -2,18 +2,22 @@
 
 from __future__ import annotations
 
+import json
 import logging
 from decimal import Decimal
 from typing import Optional
 
 import httpx
 from pydantic import BaseModel, Field
+from sqlalchemy import update
 from web3 import Web3
 
 from intentkit.clients.web3 import get_web3_client
 from intentkit.config.config import config
-from intentkit.models.agent import Agent
+from intentkit.models.agent import Agent, AgentTable
 from intentkit.models.agent_data import AgentData
+from intentkit.models.db import get_session
+from intentkit.models.redis import get_redis
 from intentkit.utils.error import IntentKitAPIError
 
 logger = logging.getLogger(__name__)
@@ -171,29 +175,72 @@ async def _build_assets_list(
 
 async def agent_asset(agent_id: str) -> AgentAssets:
     """Fetch wallet net worth and token balances for an agent."""
+
+    cache_key = f"intentkit:agent_assets:{agent_id}"
+    redis_client = None
+
+    try:
+        redis_client = get_redis()
+    except Exception as exc:  # pragma: no cover - best effort fallback
+        logger.debug("Redis unavailable for agent assets: %s", exc)
+
     agent = await Agent.get(agent_id)
     if not agent:
         raise IntentKitAPIError(404, "AgentNotFound", "Agent not found")
 
+    if redis_client:
+        try:
+            cached_raw = await redis_client.get(cache_key)
+            if cached_raw:
+                cached_data = json.loads(cached_raw)
+                cached_assets = AgentAssets.model_validate(cached_data)
+                return cached_assets
+        except Exception as exc:  # pragma: no cover - cache read path only
+            logger.debug("Failed to read agent asset cache for %s: %s", agent_id, exc)
+
     agent_data = await AgentData.get(agent_id)
     if not agent_data or not agent_data.evm_wallet_address:
-        return AgentAssets(net_worth="0", tokens=[])
-
-    if not agent.network_id:
-        return AgentAssets(net_worth="0", tokens=[])
+        assets_result = AgentAssets(net_worth="0", tokens=[])
+    elif not agent.network_id:
+        assets_result = AgentAssets(net_worth="0", tokens=[])
+    else:
+        try:
+            web3_client = get_web3_client(str(agent.network_id))
+            tokens = await _build_assets_list(agent, agent_data, web3_client)
+            net_worth = await _get_wallet_net_worth(agent_data.evm_wallet_address)
+            assets_result = AgentAssets(net_worth=net_worth, tokens=tokens)
+        except IntentKitAPIError:
+            raise
+        except Exception as exc:
+            logger.error("Error getting agent assets for %s: %s", agent_id, exc)
+            raise IntentKitAPIError(
+                500, "AgentAssetError", "Failed to retrieve agent assets"
+            ) from exc
+
+    assets_payload = assets_result.model_dump(mode="json")
+
+    if redis_client:
+        try:
+            await redis_client.set(
+                cache_key,
+                json.dumps(assets_payload),
+                ex=3600,
+            )
+        except Exception as exc:  # pragma: no cover - cache write path only
+            logger.debug("Failed to write agent asset cache for %s: %s", agent_id, exc)
 
     try:
-        web3_client = get_web3_client(str(agent.network_id))
-        tokens = await _build_assets_list(agent, agent_data, web3_client)
-        net_worth = await _get_wallet_net_worth(agent_data.evm_wallet_address)
-        return AgentAssets(net_worth=net_worth, tokens=tokens)
-    except IntentKitAPIError:
-        raise
-    except Exception as exc:
-        logger.error("Error getting agent assets for %s: %s", agent_id, exc)
-        raise IntentKitAPIError(
-            500, "AgentAssetError", "Failed to retrieve agent assets"
-        ) from exc
+        async with get_session() as session:
+            await session.execute(
+                update(AgentTable)
+                .where(AgentTable.id == agent_id)
+                .values(assets=assets_payload)
+            )
+            await session.commit()
+    except Exception as exc:  # pragma: no cover - db persistence path only
+        logger.error("Error updating agent assets cache for %s: %s", agent_id, exc)
+
+    return assets_result
 
 
 __all__ = [

intentkit/core/engine.py

@@ -36,7 +36,6 @@ from sqlalchemy.exc import SQLAlchemyError
 
 from intentkit.abstracts.graph import AgentContext, AgentError, AgentState
 from intentkit.config.config import config
-from intentkit.core.agent import agent_store
 from intentkit.core.chat import clear_thread_memory
 from intentkit.core.credit import expense_message, expense_skill
 from intentkit.core.node import PreModelNode, post_model_node
@@ -56,7 +55,7 @@ from intentkit.models.chat import (
 from intentkit.models.credit import CreditAccount, OwnerType
 from intentkit.models.db import get_langgraph_checkpointer, get_session
 from intentkit.models.llm import LLMModelInfo, LLMProvider, create_llm_model
-from intentkit.models.skill import AgentSkillData, ThreadSkillData
+from intentkit.models.skill import AgentSkillData, ChatSkillData, Skill
 from intentkit.models.user import User
 from intentkit.utils.error import IntentKitAPIError
 
@@ -70,7 +69,9 @@ _agents: dict[str, CompiledStateGraph] = {}
 _agents_updated: dict[str, datetime] = {}
 
 
-async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph:
+async def build_agent(
+    agent: Agent, agent_data: AgentData, custom_skills: list[BaseTool] = []
+) -> CompiledStateGraph:
     """Build an AI agent with specified configuration and tools.
 
     This function:
@@ -82,7 +83,8 @@ async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph
     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.
+        custom_skills (list[BaseTool], optional): Designed for advanced user who directly
+            call this function to inject custom skills into the agent tool node.
 
     Returns:
         CompiledStateGraph: Initialized LangChain agent
@@ -112,13 +114,13 @@ async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph
                 if hasattr(skill_module, "get_skills"):
                     # all
                     skill_tools = await skill_module.get_skills(
-                        v, False, agent_store, agent_id=agent.id, agent=agent
+                        v, False, agent_id=agent.id, agent=agent
                     )
                     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, agent=agent
+                        v, True, agent_id=agent.id, agent=agent
                     )
                     if skill_private_tools and len(skill_private_tools) > 0:
                         private_tools.extend(skill_private_tools)
@@ -127,6 +129,10 @@ async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph
             except ImportError as e:
                 logger.error(f"Could not import skill module: {k} ({e})")
 
+    # add custom skills to private tools
+    if custom_skills and len(custom_skills) > 0:
+        private_tools.extend(custom_skills)
+
     # 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())
@@ -696,6 +702,9 @@ async def stream_agent_raw(
                         for skill_call in skill_calls:
                             if not skill_call["success"]:
                                 continue
+                            skill = await Skill.get(skill_call["name"])
+                            if not skill:
+                                continue
                             payment_event = await expense_skill(
                                 session,
                                 payer,
@@ -889,7 +898,7 @@ async def clean_agent_memory(
 
         if clean_skill:
             await AgentSkillData.clean_data(agent_id)
-            await ThreadSkillData.clean_data(agent_id, chat_id)
+            await ChatSkillData.clean_data(agent_id, chat_id)
 
         async with get_session() as db:
             if clean_agent:

intentkit/core/scheduler.py

@@ -11,7 +11,6 @@ from apscheduler.triggers.cron import CronTrigger
 from intentkit.core.agent import (
     update_agent_action_cost,
     update_agents_account_snapshot,
-    update_agents_assets,
     update_agents_statistics,
 )
 from intentkit.core.credit import refill_all_free_credits
@@ -63,13 +62,14 @@ def create_scheduler(
     )
 
     # Update agent assets daily at UTC midnight
-    scheduler.add_job(
-        update_agents_assets,
-        trigger=CronTrigger(hour=0, minute=0, timezone="UTC"),
-        id="update_agent_assets",
-        name="Update agent assets",
-        replace_existing=True,
-    )
+    # This is too expensive to run daily, so it will only be triggered when detail page is visited
+    # scheduler.add_job(
+    #     update_agents_assets,
+    #     trigger=CronTrigger(hour=0, minute=0, timezone="UTC"),
+    #     id="update_agent_assets",
+    #     name="Update agent assets",
+    #     replace_existing=True,
+    # )
 
     # Update agent action costs hourly at minute 40
     scheduler.add_job(