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

intentkit/core/agent.py

@@ -1,137 +1,92 @@
 import logging
 import time
-from datetime import datetime, timedelta, timezone
+from collections.abc import AsyncGenerator
+from datetime import UTC, datetime, timedelta
 from decimal import Decimal
-from typing import Any, Dict, List, Optional
 
-from aiogram import Bot
-from aiogram.exceptions import TelegramConflictError, TelegramUnauthorizedError
-from aiogram.utils.token import TokenValidationError
 from sqlalchemy import func, select, text, update
 
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.clients.cdp import get_cdp_client
+from intentkit.clients.cdp import get_wallet_provider
 from intentkit.config.config import config
 from intentkit.models.agent import (
     Agent,
-    AgentAutonomous,
     AgentCreate,
-    AgentResponse,
     AgentTable,
     AgentUpdate,
 )
-from intentkit.models.agent_data import AgentData, AgentQuota, AgentQuotaTable
-from intentkit.models.credit import CreditEventTable, EventType, UpstreamType
-from intentkit.models.db import get_session
-from intentkit.models.skill import (
-    AgentSkillData,
-    AgentSkillDataCreate,
-    ThreadSkillData,
-    ThreadSkillDataCreate,
+from intentkit.models.agent_data import AgentData, AgentQuotaTable
+from intentkit.models.credit import (
+    CreditAccount,
+    CreditEventTable,
+    EventType,
+    OwnerType,
+    UpstreamType,
 )
+from intentkit.models.db import get_session
 from intentkit.utils.error import IntentKitAPIError
 from intentkit.utils.slack_alert import send_slack_message
 
 logger = logging.getLogger(__name__)
 
 
-async def _process_agent_post_actions(
-    agent: Agent, is_new: bool = True, slack_message: str | None = None
+async def process_agent_wallet(
+    agent: Agent, old_wallet_provider: str | None = None
 ) -> AgentData:
-    """Process common actions after agent creation or update.
+    """Process agent wallet initialization and validation.
 
     Args:
         agent: The agent that was created or updated
-        is_new: Whether the agent is newly created
-        slack_message: Optional custom message for Slack notification
+        old_wallet_provider: Previous wallet provider (None, "cdp", or "readonly")
 
     Returns:
         AgentData: The processed agent data
+
+    Raises:
+        IntentKitAPIError: If attempting to change between cdp and readonly providers
     """
-    if config.cdp_api_key_id and agent.wallet_provider == "cdp":
-        cdp_client = await get_cdp_client(agent.id, agent_store)
-        await cdp_client.get_wallet_provider()
+    current_wallet_provider = agent.wallet_provider
+
+    # 1. Check if changing between cdp and readonly (not allowed)
+    if (
+        old_wallet_provider is not None
+        and old_wallet_provider != "none"
+        and old_wallet_provider != current_wallet_provider
+    ):
+        raise IntentKitAPIError(
+            400,
+            "WalletProviderChangeNotAllowed",
+            "Cannot change wallet provider between cdp and readonly",
+        )
 
-    # Get new agent data
-    # FIXME: refuse to change wallet provider
-    if agent.wallet_provider == "readonly":
+    # 2. If wallet provider hasn't changed, return existing agent data
+    if (
+        old_wallet_provider is not None
+        and old_wallet_provider != "none"
+        and old_wallet_provider == current_wallet_provider
+    ):
+        return await AgentData.get(agent.id)
+
+    # 3. For new agents (old_wallet_provider is None), check if wallet already exists
+    agent_data = await AgentData.get(agent.id)
+    if agent_data.evm_wallet_address:
+        return agent_data
+
+    # 4. Initialize wallet based on provider type
+    if config.cdp_api_key_id and current_wallet_provider == "cdp":
+        await get_wallet_provider(agent)
+        agent_data = await AgentData.get(agent.id)
+    elif current_wallet_provider == "readonly":
         agent_data = await AgentData.patch(
             agent.id,
             {
                 "evm_wallet_address": agent.readonly_wallet_address,
             },
         )
-    else:
-        agent_data = await AgentData.get(agent.id)
-
-    # Send Slack notification
-    slack_message = slack_message or ("Agent Created" if is_new else "Agent Updated")
-    try:
-        _send_agent_notification(agent, agent_data, slack_message)
-    except Exception as e:
-        logger.error("Failed to send Slack notification: %s", e)
 
     return agent_data
 
 
-async def _process_telegram_config(
-    agent: AgentUpdate, existing_agent: Optional[Agent], agent_data: AgentData
-) -> AgentData:
-    """Process telegram configuration for an agent.
-
-    Args:
-        agent: The agent with telegram configuration
-        existing_agent: The existing agent (if updating)
-        agent_data: The agent data to update
-
-    Returns:
-        AgentData: The updated agent data
-    """
-    changes = agent.model_dump(exclude_unset=True)
-    if not changes.get("telegram_entrypoint_enabled"):
-        return agent_data
-
-    if not changes.get("telegram_config") or not changes.get("telegram_config").get(
-        "token"
-    ):
-        return agent_data
-
-    tg_bot_token = changes.get("telegram_config").get("token")
-
-    if existing_agent and existing_agent.telegram_config.get("token") == tg_bot_token:
-        return agent_data
-
-    try:
-        bot = Bot(token=tg_bot_token)
-        bot_info = await bot.get_me()
-        agent_data.telegram_id = str(bot_info.id)
-        agent_data.telegram_username = bot_info.username
-        agent_data.telegram_name = bot_info.first_name
-        if bot_info.last_name:
-            agent_data.telegram_name = f"{bot_info.first_name} {bot_info.last_name}"
-        await agent_data.save()
-        try:
-            await bot.close()
-        except Exception:
-            pass
-        return agent_data
-    except (
-        TelegramUnauthorizedError,
-        TelegramConflictError,
-        TokenValidationError,
-    ) as req_err:
-        logger.error(
-            f"Unauthorized err getting telegram bot username with token {tg_bot_token}: {req_err}",
-        )
-        return agent_data
-    except Exception as e:
-        logger.error(
-            f"Error getting telegram bot username with token {tg_bot_token}: {e}",
-        )
-        return agent_data
-
-
-def _send_agent_notification(agent: Agent, agent_data: AgentData, message: str) -> None:
+def send_agent_notification(agent: Agent, agent_data: AgentData, message: str) -> None:
     """Send a notification about agent creation or update.
 
     Args:
@@ -202,7 +157,7 @@ def _send_agent_notification(agent: Agent, agent_data: AgentData, message: str)
                     {
                         "title": "Network",
                         "short": True,
-                        "value": agent.network_id or "Default",
+                        "value": agent.network_id or "Not Set",
                     },
                     {
                         "title": "X Username",
@@ -237,71 +192,122 @@ def _send_agent_notification(agent: Agent, agent_data: AgentData, message: str)
     )
 
 
-async def deploy_agent(
-    agent_id: str, agent: AgentUpdate, owner: Optional[str] = None
-) -> AgentResponse:
-    """Override an existing agent.
+async def override_agent(
+    agent_id: str, agent: AgentUpdate, owner: str | None = None
+) -> tuple[Agent, AgentData]:
+    """Override an existing agent with new configuration.
 
-    Use input to override agent configuration. If some fields are not provided, they will be reset to default values.
+    This function updates an existing agent with the provided configuration.
+    If some fields are not provided, they will be reset to default values.
 
     Args:
-        agent_id: ID of the agent to update
-        agent: Agent update configuration
-        owner: Optional owner for the agent
+        agent_id: ID of the agent to override
+        agent: Agent update configuration containing the new settings
+        owner: Optional owner for permission validation
 
     Returns:
-        AgentResponse: Updated agent configuration with additional processed data
+        tuple[Agent, AgentData]: Updated agent configuration and processed agent data
 
     Raises:
-        HTTPException:
-            - 400: Invalid agent ID format
+        IntentKitAPIError:
             - 404: Agent not found
             - 403: Permission denied (if owner mismatch)
-            - 500: Database error
+            - 400: Invalid configuration or wallet provider change
     """
     existing_agent = await Agent.get(agent_id)
     if not existing_agent:
-        agent = AgentCreate.model_validate(input)
-        agent.id = agent_id
-        if owner:
-            agent.owner = owner
-        else:
-            agent.owner = "system"
-        # Check for existing agent by upstream_id, forward compatibility, raise error after 3.0
-        existing = await agent.get_by_upstream_id()
-        if existing:
-            agent_data = await AgentData.get(existing.id)
-            agent_response = await AgentResponse.from_agent(existing, agent_data)
-            return agent_response
-
-        # Create new agent
-        latest_agent = await agent.create()
-        # Process common post-creation actions
-        agent_data = await _process_agent_post_actions(
-            latest_agent, True, "Agent Created"
+        raise IntentKitAPIError(
+            status_code=404,
+            key="AgentNotFound",
+            message=f"Agent with ID '{agent_id}' not found",
         )
-        agent_data = await _process_telegram_config(input, None, agent_data)
-        agent_response = await AgentResponse.from_agent(latest_agent, agent_data)
-
-        return agent_response
-
     if owner and owner != existing_agent.owner:
-        raise IntentKitAPIError(403, "forbidden", "forbidden")
+        raise IntentKitAPIError(403, "Forbidden", "forbidden")
 
     # Update agent
     latest_agent = await agent.override(agent_id)
-
-    # Process common post-update actions
-    agent_data = await _process_agent_post_actions(
-        latest_agent, False, "Agent Overridden"
+    agent_data = await process_agent_wallet(
+        latest_agent, existing_agent.wallet_provider
     )
-    agent_data = await _process_telegram_config(agent, existing_agent, agent_data)
-    agent_response = await AgentResponse.from_agent(latest_agent, agent_data)
+    send_agent_notification(latest_agent, agent_data, "Agent Overridden Deployed")
+
+    return latest_agent, agent_data
+
 
-    return agent_response
+async def create_agent(agent: AgentCreate) -> tuple[Agent, AgentData]:
+    """Create a new agent with the provided configuration.
 
+    This function creates a new agent instance with the given configuration,
+    initializes its wallet, and sends a notification about the creation.
 
-async def agent_action_cost(agent_id: str) -> Dict[str, Decimal]:
+    Args:
+        agent: Agent creation configuration containing all necessary settings
+
+    Returns:
+        tuple[Agent, AgentData]: Created agent configuration and processed agent data
+
+    Raises:
+        IntentKitAPIError:
+            - 400: Agent with upstream ID already exists or invalid configuration
+            - 500: Database error or wallet initialization failure
+    """
+    if not agent.owner:
+        agent.owner = "system"
+    # Check for existing agent by upstream_id, forward compatibility, raise error after 3.0
+    existing = await agent.get_by_upstream_id()
+    if existing:
+        raise IntentKitAPIError(
+            status_code=400,
+            key="BadRequest",
+            message="Agent with this upstream ID already exists",
+        )
+
+    # Create new agent
+    latest_agent = await agent.create()
+    agent_data = await process_agent_wallet(latest_agent)
+    send_agent_notification(latest_agent, agent_data, "Agent Deployed")
+
+    return latest_agent, agent_data
+
+
+async def deploy_agent(
+    agent_id: str, agent: AgentUpdate, owner: str | None = None
+) -> tuple[Agent, AgentData]:
+    """Deploy an agent by first attempting to override, then creating if not found.
+
+    This function first tries to override an existing agent. If the agent is not found
+    (404 error), it will create a new agent instead.
+
+    Args:
+        agent_id: ID of the agent to deploy
+        agent: Agent configuration data
+        owner: Optional owner for the agent
+
+    Returns:
+        tuple[Agent, AgentData]: Deployed agent configuration and processed agent data
+
+    Raises:
+        IntentKitAPIError:
+            - 400: Invalid agent configuration or upstream ID conflict
+            - 403: Permission denied (if owner mismatch)
+            - 500: Database error
+    """
+    try:
+        # First try to override the existing agent
+        return await override_agent(agent_id, agent, owner)
+    except IntentKitAPIError as e:
+        # If agent not found (404), create a new one
+        if e.status_code == 404:
+            new_agent = AgentCreate.model_validate(agent)
+            new_agent.id = agent_id
+            new_agent.owner = owner
+            return await create_agent(new_agent)
+        else:
+            # Re-raise other errors
+            raise
+
+
+async def agent_action_cost(agent_id: str) -> dict[str, Decimal]:
     """
     Calculate various action cost metrics for an agent based on past three days of credit events.
 
@@ -317,7 +323,7 @@ async def agent_action_cost(agent_id: str) -> Dict[str, Decimal]:
         agent_id: ID of the agent
 
     Returns:
-        Dict[str, Decimal]: Dictionary containing all calculated cost metrics
+        dict[str, Decimal]: Dictionary containing all calculated cost metrics
     """
     start_time = time.time()
     default_value = Decimal("0")
@@ -330,7 +336,7 @@ async def agent_action_cost(agent_id: str) -> Dict[str, Decimal]:
 
     async with get_session() as session:
         # Calculate the date 3 days ago from now
-        three_days_ago = datetime.now(timezone.utc) - timedelta(days=3)
+        three_days_ago = datetime.now(UTC) - timedelta(days=3)
 
         # First, count the number of distinct start_message_ids to determine if we have enough data
         count_query = select(
@@ -478,183 +484,31 @@ 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
+async def _iterate_agent_id_batches(
+    batch_size: int = 100,
+) -> AsyncGenerator[list[str], None]:
+    """Yield agent IDs in ascending batches to limit memory usage."""
 
-        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.
+    last_id: str | None = None
+    while True:
+        async with get_session() as session:
+            query = select(AgentTable.id).order_by(AgentTable.id)
 
-        Args:
-            agent_id: ID of the agent
-            task_id: ID of the task to update
-            task_updates: Dictionary containing fields to update
+            if last_id:
+                query = query.where(AgentTable.id > last_id)
 
-        Returns:
-            AgentAutonomous: The updated task
-        """
-        return await update_autonomous_task(agent_id, task_id, task_updates)
+            query = query.limit(batch_size)
+            result = await session.execute(query)
+            agent_ids = [row[0] for row in result]
 
+        if not agent_ids:
+            break
 
-agent_store = AgentStore()
+        yield agent_ids
+        last_id = agent_ids[-1]
 
 
-async def update_agent_action_cost():
+async def update_agent_action_cost(batch_size: int = 100) -> None:
     """
     Update action costs for all agents.
 
@@ -671,42 +525,20 @@ async def update_agent_action_cost():
     """
     logger.info("Starting update of agent average action costs")
     start_time = time.time()
-    batch_size = 100
-    last_id = None
     total_updated = 0
 
-    while True:
-        # Get a batch of agent IDs ordered by ID
-        async with get_session() as session:
-            query = select(AgentTable.id).order_by(AgentTable.id)
-
-            # Apply pagination if we have a last_id from previous batch
-            if last_id:
-                query = query.where(AgentTable.id > last_id)
-
-            query = query.limit(batch_size)
-            result = await session.execute(query)
-            agent_ids = [row[0] for row in result]
-
-            # If no more agents, we're done
-            if not agent_ids:
-                break
-
-            # Update last_id for next batch
-            last_id = agent_ids[-1]
-
-        # Process this batch of agents
+    async for agent_ids in _iterate_agent_id_batches(batch_size):
         logger.info(
-            f"Processing batch of {len(agent_ids)} agents starting with ID {agent_ids[0]}"
+            "Processing batch of %s agents starting with ID %s",
+            len(agent_ids),
+            agent_ids[0],
         )
         batch_start_time = time.time()
 
         for agent_id in agent_ids:
             try:
-                # Calculate action costs for this agent
                 costs = await agent_action_cost(agent_id)
 
-                # Update the agent's quota record
                 async with get_session() as session:
                     update_stmt = (
                         update(AgentQuotaTable)
@@ -724,203 +556,186 @@ async def update_agent_action_cost():
                     await session.commit()
 
                 total_updated += 1
-            except Exception as e:
+            except Exception as e:  # pragma: no cover - log path only
                 logger.error(
-                    f"Error updating action costs for agent {agent_id}: {str(e)}"
+                    "Error updating action costs for agent %s: %s", agent_id, str(e)
                 )
 
         batch_time = time.time() - batch_start_time
-        logger.info(f"Completed batch in {batch_time:.3f}s")
+        logger.info("Completed batch in %.3fs", batch_time)
 
     total_time = time.time() - start_time
     logger.info(
-        f"Finished updating action costs for {total_updated} agents in {total_time:.3f}s"
+        "Finished updating action costs for %s agents in %.3fs",
+        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
+async def update_agents_account_snapshot(batch_size: int = 100) -> None:
+    """Refresh the cached credit account snapshot for every agent."""
 
-    Returns:
-        List[AgentAutonomous]: List of autonomous task configurations
+    logger.info("Starting update of agent account snapshots")
+    start_time = time.time()
+    total_updated = 0
 
-    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."
+    async for agent_ids in _iterate_agent_id_batches(batch_size):
+        logger.info(
+            "Processing snapshot batch of %s agents starting with ID %s",
+            len(agent_ids),
+            agent_ids[0],
         )
+        batch_start_time = time.time()
 
-    if not agent.autonomous:
-        return []
-
-    return agent.autonomous
-
+        for agent_id in agent_ids:
+            try:
+                async with get_session() as session:
+                    account = await CreditAccount.get_or_create_in_session(
+                        session, OwnerType.AGENT, agent_id
+                    )
+                    await session.execute(
+                        update(AgentTable)
+                        .where(AgentTable.id == agent_id)
+                        .values(
+                            account_snapshot=account.model_dump(mode="json"),
+                        )
+                    )
+                    await session.commit()
 
-async def add_autonomous_task(agent_id: str, task: AgentAutonomous) -> AgentAutonomous:
-    """
-    Add a new autonomous task to an agent.
+                total_updated += 1
+            except Exception as exc:  # pragma: no cover - log path only
+                logger.error(
+                    "Error updating account snapshot for agent %s: %s",
+                    agent_id,
+                    exc,
+                )
 
-    Args:
-        agent_id: ID of the agent
-        task: Autonomous task configuration (id will be generated if not provided)
+        batch_time = time.time() - batch_start_time
+        logger.info("Completed snapshot batch in %.3fs", batch_time)
 
-    Returns:
-        AgentAutonomous: The created task with generated ID
+    total_time = time.time() - start_time
+    logger.info(
+        "Finished updating account snapshots for %s agents in %.3fs",
+        total_updated,
+        total_time,
+    )
 
-    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 = []
+async def update_agents_assets(batch_size: int = 100) -> None:
+    """Refresh cached asset information for all agents."""
 
-    # Add the new task
-    current_tasks.append(task)
+    from intentkit.core.asset import agent_asset
 
-    # Convert all AgentAutonomous objects to dictionaries for JSON serialization
-    serializable_tasks = [task_item.model_dump() for task_item in current_tasks]
+    logger.info("Starting update of agent assets")
+    start_time = time.time()
+    total_updated = 0
 
-    # 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)
+    async for agent_ids in _iterate_agent_id_batches(batch_size):
+        logger.info(
+            "Processing asset batch of %s agents starting with ID %s",
+            len(agent_ids),
+            agent_ids[0],
         )
-        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.
+        batch_start_time = time.time()
 
-    Args:
-        agent_id: ID of the agent
-        task_id: ID of the task to delete
+        for agent_id in agent_ids:
+            try:
+                assets = await agent_asset(agent_id)
+            except IntentKitAPIError as exc:  # pragma: no cover - log path only
+                logger.warning(
+                    "Skipping asset update for agent %s due to API error: %s",
+                    agent_id,
+                    exc,
+                )
+                continue
+            except Exception as exc:  # pragma: no cover - log path only
+                logger.error("Error retrieving assets for agent %s: %s", agent_id, exc)
+                continue
 
-    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."
-        )
+            try:
+                async with get_session() as session:
+                    await session.execute(
+                        update(AgentTable)
+                        .where(AgentTable.id == agent_id)
+                        .values(assets=assets.model_dump(mode="json"))
+                    )
+                    await session.commit()
 
-    # 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."
-        )
+                total_updated += 1
+            except Exception as exc:  # pragma: no cover - log path only
+                logger.error(
+                    "Error updating asset cache for agent %s: %s", agent_id, exc
+                )
 
-    # Convert remaining AgentAutonomous objects to dictionaries for JSON serialization
-    serializable_tasks = [task_item.model_dump() for task_item in updated_tasks]
+        batch_time = time.time() - batch_start_time
+        logger.info("Completed asset batch in %.3fs", batch_time)
 
-    # 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()
+    total_time = time.time() - start_time
+    logger.info(
+        "Finished updating assets for %s agents in %.3fs",
+        total_updated,
+        total_time,
+    )
 
-    logger.info(f"Deleted autonomous task {task_id} from agent {agent_id}")
 
+async def update_agents_statistics(
+    *, end_time: datetime | None = None, batch_size: int = 100
+) -> None:
+    """Refresh cached statistics for every agent."""
 
-async def update_autonomous_task(
-    agent_id: str, task_id: str, task_updates: dict
-) -> AgentAutonomous:
-    """
-    Update an autonomous task for an agent.
+    from intentkit.core.statistics import get_agent_statistics
 
-    Args:
-        agent_id: ID of the agent
-        task_id: ID of the task to update
-        task_updates: Dictionary containing fields to update
+    if end_time is None:
+        end_time = datetime.now(UTC)
+    elif end_time.tzinfo is None:
+        end_time = end_time.replace(tzinfo=UTC)
+    else:
+        end_time = end_time.astimezone(UTC)
 
-    Returns:
-        AgentAutonomous: The updated task
+    logger.info("Starting update of agent statistics using end_time %s", end_time)
+    start_time = time.time()
+    total_updated = 0
 
-    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."
+    async for agent_ids in _iterate_agent_id_batches(batch_size):
+        logger.info(
+            "Processing statistics batch of %s agents starting with ID %s",
+            len(agent_ids),
+            agent_ids[0],
         )
+        batch_start_time = time.time()
 
-    # 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)
+        for agent_id in agent_ids:
+            try:
+                statistics = await get_agent_statistics(agent_id, end_time=end_time)
+            except Exception as exc:  # pragma: no cover - log path only
+                logger.error(
+                    "Error computing statistics for agent %s: %s", agent_id, exc
+                )
+                continue
 
-    if not task_found:
-        raise IntentKitAPIError(
-            404, "TaskNotFound", f"Autonomous task with ID {task_id} not found."
-        )
+            try:
+                async with get_session() as session:
+                    await session.execute(
+                        update(AgentTable)
+                        .where(AgentTable.id == agent_id)
+                        .values(statistics=statistics.model_dump(mode="json"))
+                    )
+                    await session.commit()
 
-    # Convert all AgentAutonomous objects to dictionaries for JSON serialization
-    serializable_tasks = [task_item.model_dump() for task_item in updated_tasks]
+                total_updated += 1
+            except Exception as exc:  # pragma: no cover - log path only
+                logger.error(
+                    "Error updating statistics cache for agent %s: %s",
+                    agent_id,
+                    exc,
+                )
 
-    # 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()
+        batch_time = time.time() - batch_start_time
+        logger.info("Completed statistics batch in %.3fs", batch_time)
 
-    logger.info(f"Updated autonomous task {task_id} for agent {agent_id}")
-    return updated_task
+    total_time = time.time() - start_time
+    logger.info(
+        "Finished updating statistics for %s agents in %.3fs",
+        total_updated,
+        total_time,
+    )