intentkit 0.7.5.dev26__py3-none-any.whl → 0.7.5.dev28__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-dev26"
+__version__ = "0.7.5-dev28"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

intentkit/core/agent.py

@@ -2,7 +2,7 @@ import logging
 import time
 from datetime import datetime, timedelta, timezone
 from decimal import Decimal
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple
 
 from sqlalchemy import func, select, text, update
 
@@ -17,7 +17,13 @@ from intentkit.models.agent import (
     AgentUpdate,
 )
 from intentkit.models.agent_data import AgentData, AgentQuota, AgentQuotaTable
-from intentkit.models.credit import CreditEventTable, EventType, UpstreamType
+from intentkit.models.credit import (
+    CreditAccount,
+    CreditEventTable,
+    EventType,
+    OwnerType,
+    UpstreamType,
+)
 from intentkit.models.db import get_session
 from intentkit.models.skill import (
     AgentSkillData,
@@ -660,7 +666,31 @@ class AgentStore(SkillStoreABC):
 agent_store = AgentStore()
 
 
-async def update_agent_action_cost():
+async def _iterate_agent_id_batches(
+    batch_size: int = 100,
+) -> AsyncGenerator[list[str], None]:
+    """Yield agent IDs in ascending batches to limit memory usage."""
+
+    last_id: Optional[str] = None
+    while True:
+        async with get_session() as session:
+            query = select(AgentTable.id).order_by(AgentTable.id)
+
+            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 not agent_ids:
+            break
+
+        yield agent_ids
+        last_id = agent_ids[-1]
+
+
+async def update_agent_action_cost(batch_size: int = 100) -> None:
     """
     Update action costs for all agents.
 
@@ -677,42 +707,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)
@@ -730,17 +738,188 @@ 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(
+                    "Error updating action costs for agent %s: %s", agent_id, str(e)
+                )
+
+        batch_time = time.time() - batch_start_time
+        logger.info("Completed batch in %.3fs", batch_time)
+
+    total_time = time.time() - start_time
+    logger.info(
+        "Finished updating action costs for %s agents in %.3fs",
+        total_updated,
+        total_time,
+    )
+
+
+async def update_agents_account_snapshot(batch_size: int = 100) -> None:
+    """Refresh the cached credit account snapshot for every agent."""
+
+    logger.info("Starting update of agent account snapshots")
+    start_time = time.time()
+    total_updated = 0
+
+    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()
+
+        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()
+
+                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,
+                )
+
+        batch_time = time.time() - batch_start_time
+        logger.info("Completed snapshot batch in %.3fs", batch_time)
+
+    total_time = time.time() - start_time
+    logger.info(
+        "Finished updating account snapshots for %s agents in %.3fs",
+        total_updated,
+        total_time,
+    )
+
+
+async def update_agents_assets(batch_size: int = 100) -> None:
+    """Refresh cached asset information for all agents."""
+
+    from intentkit.core.asset import agent_asset
+
+    logger.info("Starting update of agent assets")
+    start_time = time.time()
+    total_updated = 0
+
+    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],
+        )
+        batch_start_time = time.time()
+
+        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
+
+            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()
+
+                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
+                )
+
+        batch_time = time.time() - batch_start_time
+        logger.info("Completed asset batch in %.3fs", batch_time)
+
+    total_time = time.time() - start_time
+    logger.info(
+        "Finished updating assets for %s agents in %.3fs",
+        total_updated,
+        total_time,
+    )
+
+
+async def update_agents_statistics(
+    *, end_time: Optional[datetime] = None, batch_size: int = 100
+) -> None:
+    """Refresh cached statistics for every agent."""
+
+    from intentkit.core.statistics import get_agent_statistics
+
+    if end_time is None:
+        end_time = datetime.now(timezone.utc)
+    elif end_time.tzinfo is None:
+        end_time = end_time.replace(tzinfo=timezone.utc)
+    else:
+        end_time = end_time.astimezone(timezone.utc)
+
+    logger.info("Starting update of agent statistics using end_time %s", end_time)
+    start_time = time.time()
+    total_updated = 0
+
+    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()
+
+        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
+
+            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()
+
+                total_updated += 1
+            except Exception as exc:  # pragma: no cover - log path only
                 logger.error(
-                    f"Error updating action costs for agent {agent_id}: {str(e)}"
+                    "Error updating statistics cache for agent %s: %s",
+                    agent_id,
+                    exc,
                 )
 
         batch_time = time.time() - batch_start_time
-        logger.info(f"Completed batch in {batch_time:.3f}s")
+        logger.info("Completed statistics 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 statistics for %s agents in %.3fs",
+        total_updated,
+        total_time,
     )
 
 

intentkit/core/asset.py

@@ -0,0 +1,208 @@
+"""Shared asset retrieval utilities for agents."""
+
+from __future__ import annotations
+
+import logging
+from decimal import Decimal
+from typing import Optional
+
+import httpx
+from pydantic import BaseModel, Field
+from web3 import Web3
+
+from intentkit.clients.web3 import get_web3_client
+from intentkit.config.config import config
+from intentkit.core.agent import agent_store
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData
+from intentkit.utils.error import IntentKitAPIError
+
+logger = logging.getLogger(__name__)
+
+# USDC contract addresses for different networks
+USDC_ADDRESSES = {
+    "base-mainnet": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    "ethereum-mainnet": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    "arbitrum-mainnet": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    "optimism-mainnet": "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    "polygon-mainnet": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+}
+
+# NATION token address for base-mainnet
+NATION_ADDRESS = "0x2f74f818e81685c8086dd783837a4605a90474b8"
+
+
+class Asset(BaseModel):
+    """Model for individual asset with symbol and balance."""
+
+    symbol: str = Field(description="Asset symbol (e.g., ETH, USDC, NATION)")
+    balance: Decimal = Field(description="Asset balance as decimal")
+
+
+class AgentAssets(BaseModel):
+    """Simplified agent asset response with wallet net worth and tokens."""
+
+    net_worth: str = Field(description="Total wallet net worth in USD")
+    tokens: list[Asset] = Field(description="List of assets with symbol and balance")
+
+
+async def _get_token_balance(
+    web3_client: Web3, wallet_address: str, token_address: str
+) -> Decimal:
+    """Get ERC-20 token balance for a wallet address."""
+    try:
+        # ERC-20 standard ABI for balanceOf and decimals
+        erc20_abi = [
+            {
+                "constant": True,
+                "inputs": [{"name": "_owner", "type": "address"}],
+                "name": "balanceOf",
+                "outputs": [{"name": "balance", "type": "uint256"}],
+                "type": "function",
+            },
+            {
+                "constant": True,
+                "inputs": [],
+                "name": "decimals",
+                "outputs": [{"name": "", "type": "uint8"}],
+                "type": "function",
+            },
+        ]
+
+        contract = web3_client.eth.contract(
+            address=web3_client.to_checksum_address(token_address), abi=erc20_abi
+        )
+
+        balance_wei = contract.functions.balanceOf(
+            web3_client.to_checksum_address(wallet_address)
+        ).call()
+        decimals = contract.functions.decimals().call()
+
+        # Convert from wei to token units using actual decimals
+        balance = Decimal(balance_wei) / Decimal(10**decimals)
+        return balance
+    except Exception as exc:  # pragma: no cover - log path only
+        logger.error("Error getting token balance: %s", exc)
+        return Decimal("0")
+
+
+async def _get_eth_balance(web3_client: Web3, wallet_address: str) -> Decimal:
+    """Get ETH balance for a wallet address."""
+    try:
+        balance_wei = web3_client.eth.get_balance(
+            web3_client.to_checksum_address(wallet_address)
+        )
+        balance = Decimal(balance_wei) / Decimal(10**18)
+        return balance
+    except Exception as exc:  # pragma: no cover - log path only
+        logger.error("Error getting ETH balance: %s", exc)
+        return Decimal("0")
+
+
+async def _get_wallet_net_worth(wallet_address: str) -> str:
+    """Get wallet net worth using Moralis API."""
+    try:
+        async with httpx.AsyncClient() as client:
+            url = (
+                "https://deep-index.moralis.io/api/v2.2/wallets/"
+                f"{wallet_address}/net-worth"
+            )
+            headers = {
+                "accept": "application/json",
+                "X-API-Key": config.moralis_api_key,
+            }
+            params = {
+                "exclude_spam": "true",
+                "exclude_unverified_contracts": "true",
+                "chains": ["eth", "base", "polygon", "arbitrum", "optimism"],
+            }
+
+            response = await client.get(url, headers=headers, params=params)
+            response.raise_for_status()
+            data = response.json()
+            return data.get("total_networth_usd", "0")
+    except Exception as exc:  # pragma: no cover - log path only
+        logger.error("Error getting wallet net worth for %s: %s", wallet_address, exc)
+        return "0"
+
+
+async def _build_assets_list(
+    agent: Agent, agent_data: AgentData, web3_client: Web3
+) -> list[Asset]:
+    """Build the assets list based on network conditions and agent configuration."""
+    assets: list[Asset] = []
+
+    if not agent_data or not agent_data.evm_wallet_address:
+        return assets
+
+    wallet_address = agent_data.evm_wallet_address
+    network_id: Optional[str] = agent.network_id
+
+    # ETH is always included
+    eth_balance = await _get_eth_balance(web3_client, wallet_address)
+    assets.append(Asset(symbol="ETH", balance=eth_balance))
+
+    if network_id and network_id.endswith("-mainnet"):
+        usdc_address = USDC_ADDRESSES.get(str(network_id))
+        if usdc_address:
+            usdc_balance = await _get_token_balance(
+                web3_client, wallet_address, usdc_address
+            )
+            assets.append(Asset(symbol="USDC", balance=usdc_balance))
+
+    if network_id == "base-mainnet":
+        nation_balance = await _get_token_balance(
+            web3_client, wallet_address, NATION_ADDRESS
+        )
+        assets.append(Asset(symbol="NATION", balance=nation_balance))
+
+    if agent.ticker and agent.token_address:
+        lower_addresses = [addr.lower() for addr in USDC_ADDRESSES.values()]
+        is_usdc = agent.token_address.lower() in lower_addresses
+        is_nation = agent.token_address.lower() == NATION_ADDRESS.lower()
+
+        if not is_usdc and not is_nation:
+            custom_balance = await _get_token_balance(
+                web3_client, wallet_address, agent.token_address
+            )
+            assets.append(Asset(symbol=agent.ticker, balance=custom_balance))
+
+    return assets
+
+
+async def agent_asset(agent_id: str) -> AgentAssets:
+    """Fetch wallet net worth and token balances for an agent."""
+    agent = await Agent.get(agent_id)
+    if not agent:
+        raise IntentKitAPIError(404, "AgentNotFound", "Agent not found")
+
+    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=[])
+
+    try:
+        web3_client = get_web3_client(str(agent.network_id), agent_store)
+        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
+
+
+__all__ = [
+    "Asset",
+    "AgentAssets",
+    "USDC_ADDRESSES",
+    "NATION_ADDRESS",
+    "agent_asset",
+    "_build_assets_list",
+    "_get_wallet_net_worth",
+]

intentkit/core/statistics.py

@@ -0,0 +1,169 @@
+"""Agent statistics utilities."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from decimal import Decimal
+from typing import Optional
+
+from pydantic import BaseModel, Field
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from intentkit.models.agent_data import AgentQuota, AgentQuotaTable
+from intentkit.models.credit import CreditAccount, CreditEventTable, OwnerType
+from intentkit.models.db import get_session
+
+
+class AgentStatistics(BaseModel):
+    """Aggregated statistics for an agent credit account."""
+
+    agent_id: str = Field(description="ID of the agent")
+    account_id: str = Field(description="ID of the associated credit account")
+    balance: Decimal = Field(description="Current credit account balance")
+    total_income: Decimal = Field(description="Total income across all events")
+    net_income: Decimal = Field(description="Net income from fee allocations")
+    permanent_income: Decimal = Field(
+        description="Total permanent income across all events"
+    )
+    permanent_profit: Decimal = Field(
+        description="Permanent profit allocated to the agent"
+    )
+    last_24h_income: Decimal = Field(
+        description="Income generated during the last 24 hours"
+    )
+    last_24h_permanent_income: Decimal = Field(
+        description="Permanent income generated during the last 24 hours"
+    )
+    avg_action_cost: Decimal = Field(description="Average action cost")
+    min_action_cost: Decimal = Field(description="Minimum action cost")
+    max_action_cost: Decimal = Field(description="Maximum action cost")
+    low_action_cost: Decimal = Field(description="20th percentile action cost")
+    medium_action_cost: Decimal = Field(description="60th percentile action cost")
+    high_action_cost: Decimal = Field(description="80th percentile action cost")
+
+
+async def get_agent_statistics(
+    agent_id: str,
+    *,
+    end_time: Optional[datetime] = None,
+    session: Optional[AsyncSession] = None,
+) -> AgentStatistics:
+    """Calculate statistics for an agent credit account.
+
+    Args:
+        agent_id: ID of the agent.
+        end_time: Optional end time used as the inclusive boundary for
+            time-windowed aggregations. Defaults to the current UTC time.
+        session: Optional database session to reuse. When omitted, a
+            standalone session will be created and committed automatically.
+
+    Returns:
+        Aggregated statistics for the agent.
+    """
+
+    managed_session = session is None
+    if end_time is None:
+        end_time = datetime.now(timezone.utc)
+    elif end_time.tzinfo is None:
+        end_time = end_time.replace(tzinfo=timezone.utc)
+    else:
+        end_time = end_time.astimezone(timezone.utc)
+
+    async def _compute(session: AsyncSession) -> AgentStatistics:
+        account = await CreditAccount.get_or_create_in_session(
+            session, OwnerType.AGENT, agent_id
+        )
+        balance = account.free_credits + account.reward_credits + account.credits
+
+        totals_stmt = select(
+            func.sum(CreditEventTable.total_amount).label("total_income"),
+            func.sum(CreditEventTable.fee_agent_amount).label("net_income"),
+            func.sum(CreditEventTable.permanent_amount).label("permanent_income"),
+            func.sum(CreditEventTable.fee_agent_permanent_amount).label(
+                "permanent_profit"
+            ),
+        ).where(CreditEventTable.agent_id == agent_id)
+        totals_result = await session.execute(totals_stmt)
+        totals_row = totals_result.first()
+
+        total_income = (
+            totals_row.total_income
+            if totals_row and totals_row.total_income
+            else Decimal("0")
+        )
+        net_income = (
+            totals_row.net_income
+            if totals_row and totals_row.net_income
+            else Decimal("0")
+        )
+        permanent_income = (
+            totals_row.permanent_income
+            if totals_row and totals_row.permanent_income
+            else Decimal("0")
+        )
+        permanent_profit = (
+            totals_row.permanent_profit
+            if totals_row and totals_row.permanent_profit
+            else Decimal("0")
+        )
+
+        window_start = end_time - timedelta(hours=24)
+        window_stmt = select(
+            func.sum(CreditEventTable.total_amount).label("last_24h_income"),
+            func.sum(CreditEventTable.permanent_amount).label(
+                "last_24h_permanent_income"
+            ),
+        ).where(
+            CreditEventTable.agent_id == agent_id,
+            CreditEventTable.created_at >= window_start,
+            CreditEventTable.created_at <= end_time,
+        )
+        window_result = await session.execute(window_stmt)
+        window_row = window_result.first()
+
+        last_24h_income = (
+            window_row.last_24h_income
+            if window_row and window_row.last_24h_income
+            else Decimal("0")
+        )
+        last_24h_permanent_income = (
+            window_row.last_24h_permanent_income
+            if window_row and window_row.last_24h_permanent_income
+            else Decimal("0")
+        )
+
+        quota_row = await session.get(AgentQuotaTable, agent_id)
+        quota = (
+            AgentQuota.model_validate(quota_row)
+            if quota_row
+            else AgentQuota(id=agent_id)
+        )
+
+        return AgentStatistics(
+            agent_id=agent_id,
+            account_id=account.id,
+            balance=balance,
+            total_income=total_income,
+            net_income=net_income,
+            permanent_income=permanent_income,
+            permanent_profit=permanent_profit,
+            last_24h_income=last_24h_income,
+            last_24h_permanent_income=last_24h_permanent_income,
+            avg_action_cost=quota.avg_action_cost,
+            min_action_cost=quota.min_action_cost,
+            max_action_cost=quota.max_action_cost,
+            low_action_cost=quota.low_action_cost,
+            medium_action_cost=quota.medium_action_cost,
+            high_action_cost=quota.high_action_cost,
+        )
+
+    if managed_session:
+        async with get_session() as managed:
+            statistics = await _compute(managed)
+            await managed.commit()
+            return statistics
+    return await _compute(session)
+
+
+__all__ = ["AgentStatistics", "get_agent_statistics"]

{intentkit-0.7.5.dev26.dist-info → intentkit-0.7.5.dev28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.7.5.dev26
+Version: 0.7.5.dev28
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestalnetwork/intentkit
 Project-URL: Repository, https://github.com/crestalnetwork/intentkit

{intentkit-0.7.5.dev26.dist-info → intentkit-0.7.5.dev28.dist-info}/RECORD

@@ -1,4 +1,4 @@
-intentkit/__init__.py,sha256=4rN9u7UCNJjYV4LQCR8urA6S1ezNFBSDgvOl-nbSg-A,384
+intentkit/__init__.py,sha256=TLm-2HN623h5B0LDpMvBIq2Rf_D9u77MemTU2iwIQ0g,384
 intentkit/abstracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 intentkit/abstracts/agent.py,sha256=108gb5W8Q1Sy4G55F2_ZFv2-_CnY76qrBtpIr0Oxxqk,1489
 intentkit/abstracts/api.py,sha256=ZUc24vaQvQVbbjznx7bV0lbbQxdQPfEV8ZxM2R6wZWo,166
@@ -13,14 +13,16 @@ intentkit/clients/web3.py,sha256=A-w4vBPXHpDh8svsEFj_LkmvRgoDTZw4E-84S-UC9ws,102
 intentkit/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 intentkit/config/config.py,sha256=kw9F-uLsJd-knCKmYNb-hqR7x7HUXUkNg5FZCgOPH54,8868
 intentkit/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-intentkit/core/agent.py,sha256=7WTUouAV3uLvsJxHq4JziCMO8YdYeVujtmc--9L5ZJc,31981
+intentkit/core/agent.py,sha256=YeeaqSMHIRAWUihL4OsWwrbZy8QbV26ORddMgPtRqMc,37932
 intentkit/core/api.py,sha256=WfoaHNquujYJIpNPuTR1dSaaxog0S3X2W4lG9Ehmkm4,3284
+intentkit/core/asset.py,sha256=mswjgAhSkAzdkz8VlFCWFMrE4Di5R3tZlkHtC0Rt4D0,7397
 intentkit/core/chat.py,sha256=YN20CnDazWLjiOZFOHgV6uHmA2DKkvPCsD5Q5sfNcZg,1685
 intentkit/core/client.py,sha256=J5K7f08-ucszBKAbn9K3QNOFKIC__7amTbKYii1jFkI,3056
 intentkit/core/credit.py,sha256=b4f4T6G6eeBTMe0L_r8awWtXgUnqiog4IUaymDPYym0,75587
 intentkit/core/engine.py,sha256=8-dlYnwg8BIViAWIAFj65s3O29EXCeQlTjf5Yg9Xfww,37597
 intentkit/core/node.py,sha256=Cjekrg5RFtNNj3k_pLAWTZVGzm33Wnn2JtE__RSNMA8,8880
 intentkit/core/prompt.py,sha256=idNx1ono4Maz2i6IBKfaKOBBbEQiWbaSxr2Eb1vZTI4,15482
+intentkit/core/statistics.py,sha256=-IZmxIBzyzZuai7QyfPEY1tx8Q8ydmmcm6eqbSSy_6o,6366
 intentkit/models/agent.py,sha256=-nRcaH5b-iMyds02KvjOlogHAfOC5X184qJZj_Gung4,69074
 intentkit/models/agent_data.py,sha256=5zq3EPKnygT2P1OHc2IfEmL8hXkjeBND6sJ0JJsvQJg,28370
 intentkit/models/agent_public.json,sha256=0X8Bd2WOobDJLsok8avWNzmzu4uvKSGEyy6Myn53eT4,2802
@@ -270,8 +272,6 @@ intentkit/skills/moralis/fetch_solana_portfolio.py,sha256=rc6uqqt6_13VoveNf1mxnC
 intentkit/skills/moralis/fetch_wallet_portfolio.py,sha256=tujwVQklkkaDTnLj6Ce-hUybg_0gWr-GLTaocEmzNA4,11166
 intentkit/skills/moralis/moralis.png,sha256=fUm771g9SmL3SO2m0yeEAzrnT0C_scj_r9rowCvFiVo,11232
 intentkit/skills/moralis/schema.json,sha256=jpD66pyw1LtUXejAjWHNJy_FGXeHK-YRlRMtvFIA33g,4734
-intentkit/skills/moralis/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-intentkit/skills/moralis/tests/test_wallet.py,sha256=MI4WwFNBoILDEXlK22glntiySgR9BWkpHUdIfKUu2-A,18610
 intentkit/skills/morpho/__init__.py,sha256=03BU7URDdBCu7PEl9JNvZ1JJ0GSy3Xk7tiQJzJuNc84,1482
 intentkit/skills/morpho/base.py,sha256=FYbgul_35OX-oHwTqA8Jb99V9azM1AVcsUqGScOvQAg,238
 intentkit/skills/morpho/morpho.svg,sha256=v3snRB2CkMbaw36YbdmNRuptu5I07O-6WUw__Htciv8,602
@@ -450,7 +450,7 @@ intentkit/utils/random.py,sha256=DymMxu9g0kuQLgJUqalvgksnIeLdS-v0aRk5nQU0mLI,452
 intentkit/utils/s3.py,sha256=A8Nsx5QJyLsxhj9g7oHNy2-m24tjQUhC9URm8Qb1jFw,10057
 intentkit/utils/slack_alert.py,sha256=s7UpRgyzLW7Pbmt8cKzTJgMA9bm4EP-1rQ5KXayHu6E,2264
 intentkit/utils/tx.py,sha256=2yLLGuhvfBEY5n_GJ8wmIWLCzn0FsYKv5kRNzw_sLUI,1454
-intentkit-0.7.5.dev26.dist-info/METADATA,sha256=Jq7PY9gUq6oZwLYs5QzItmy3Jeqj9rJEgRmgWxlriBA,6360
-intentkit-0.7.5.dev26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-intentkit-0.7.5.dev26.dist-info/licenses/LICENSE,sha256=Bln6DhK-LtcO4aXy-PBcdZv2f24MlJFm_qn222biJtE,1071
-intentkit-0.7.5.dev26.dist-info/RECORD,,
+intentkit-0.7.5.dev28.dist-info/METADATA,sha256=0o_TegRevOjTNiaoB8xrvgkSa3RLiOiWRulXkbrRr0Q,6360
+intentkit-0.7.5.dev28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+intentkit-0.7.5.dev28.dist-info/licenses/LICENSE,sha256=Bln6DhK-LtcO4aXy-PBcdZv2f24MlJFm_qn222biJtE,1071
+intentkit-0.7.5.dev28.dist-info/RECORD,,

intentkit/skills/moralis/tests/test_wallet.py

@@ -1,511 +0,0 @@
-"""Tests for the Moralis Wallet Portfolio skills."""
-
-import asyncio
-import json
-import unittest
-from unittest.mock import AsyncMock, MagicMock, patch
-
-from intentkit.skills.moralis import (
-    FetchChainPortfolio,
-    FetchSolanaPortfolio,
-    FetchWalletPortfolio,
-    get_skills,
-)
-from intentkit.skills.moralis.api import (
-    fetch_moralis_data,
-    fetch_wallet_balances,
-    get_solana_portfolio,
-)
-from intentkit.skills.moralis.base import WalletBaseTool
-
-
-class DummyResponse:
-    """Mock HTTP response for testing."""
-
-    def __init__(self, status_code, json_data):
-        self.status_code = status_code
-        self._json_data = json_data
-        self.text = json.dumps(json_data) if json_data else ""
-
-    def json(self):
-        return self._json_data
-
-    async def raise_for_status(self):
-        if self.status_code >= 400:
-            raise Exception(f"HTTP Error: {self.status_code}")
-
-
-class TestWalletBaseClass(unittest.TestCase):
-    """Test the base wallet portfolio tool class."""
-
-    def setUp(self):
-        self.loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self.loop)
-
-        self.mock_skill_store = MagicMock()
-
-    def tearDown(self):
-        self.loop.close()
-
-    def test_base_class_init(self):
-        """Test base class initialization."""
-
-        # Create a concrete subclass for testing
-        class TestTool(WalletBaseTool):
-            async def _arun(self, *args, **kwargs):
-                return "test"
-
-        tool = TestTool(
-            name="test_tool",
-            description="Test tool",
-            args_schema=MagicMock(),
-            api_key="test_key",
-            skill_store=self.mock_skill_store,
-            agent_id="test_agent",
-        )
-
-        self.assertEqual(tool.api_key, "test_key")
-        self.assertEqual(tool.agent_id, "test_agent")
-        self.assertEqual(tool.skill_store, self.mock_skill_store)
-        self.assertEqual(tool.category, "moralis")
-
-    def test_get_chain_name(self):
-        """Test chain name conversion."""
-
-        class TestTool(WalletBaseTool):
-            async def _arun(self, *args, **kwargs):
-                return "test"
-
-        tool = TestTool(
-            name="test_tool",
-            description="Test tool",
-            args_schema=MagicMock(),
-            api_key="test_key",
-            skill_store=self.mock_skill_store,
-            agent_id="test_agent",
-        )
-
-        # Test with known chain IDs
-        self.assertEqual(tool._get_chain_name(1), "eth")
-        self.assertEqual(tool._get_chain_name(56), "bsc")
-        self.assertEqual(tool._get_chain_name(137), "polygon")
-
-        # Test with unknown chain ID
-        self.assertEqual(tool._get_chain_name(999999), "eth")
-
-
-class TestAPIFunctions(unittest.IsolatedAsyncioTestCase):
-    """Test the API interaction functions."""
-
-    async def test_fetch_moralis_data(self):
-        """Test the base Moralis API function."""
-        with patch("httpx.AsyncClient") as MockClient:
-            client_instance = AsyncMock()
-            client_instance.get.return_value = DummyResponse(
-                200, {"success": True, "data": "test_data"}
-            )
-            MockClient.return_value.__aenter__.return_value = client_instance
-
-            result = await fetch_moralis_data(
-                "test_api_key", "test_endpoint", "0xAddress", 1
-            )
-
-            self.assertEqual(result, {"success": True, "data": "test_data"})
-
-            # Test error handling
-            client_instance.get.return_value = DummyResponse(404, None)
-            client_instance.get.return_value.raise_for_status = AsyncMock(
-                side_effect=Exception("HTTP error 404")
-            )
-
-            result = await fetch_moralis_data(
-                "test_api_key", "test_endpoint", "0xAddress", 1
-            )
-            self.assertIn("error", result)
-
-    async def test_fetch_wallet_balances(self):
-        """Test fetching wallet balances."""
-        with patch("skills.moralis.api.fetch_moralis_data") as mock_fetch:
-            mock_fetch.return_value = {
-                "result": [
-                    {
-                        "token_address": "0x123",
-                        "symbol": "TEST",
-                        "balance": "1000000",
-                        "usd_value": 100,
-                    }
-                ]
-            }
-
-            result = await fetch_wallet_balances("test_api_key", "0xAddress", 1)
-
-            self.assertEqual(result["result"][0]["symbol"], "TEST")
-            mock_fetch.assert_called_once_with(
-                "test_api_key", "wallets/{address}/tokens", "0xAddress", 1, None
-            )
-
-    async def test_get_solana_portfolio(self):
-        """Test getting Solana portfolio."""
-        with patch("skills.moralis.api.fetch_solana_api") as mock_fetch:
-            mock_fetch.return_value = {
-                "nativeBalance": {"solana": 1.5, "lamports": 1500000000},
-                "tokens": [
-                    {
-                        "symbol": "TEST",
-                        "name": "Test Token",
-                        "mint": "TokenMintAddress",
-                        "associatedTokenAddress": "AssocTokenAddress",
-                        "amount": 10,
-                        "decimals": 9,
-                        "amountRaw": "10000000000",
-                    }
-                ],
-            }
-
-            result = await get_solana_portfolio("test_api_key", "SolAddress", "mainnet")
-
-            mock_fetch.assert_called_once_with(
-                "test_api_key", "/account/mainnet/SolAddress/portfolio"
-            )
-            self.assertEqual(result["nativeBalance"]["solana"], 1.5)
-            self.assertEqual(len(result["tokens"]), 1)
-            self.assertEqual(result["tokens"][0]["symbol"], "TEST")
-
-
-class TestFetchWalletPortfolio(unittest.IsolatedAsyncioTestCase):
-    """Test the FetchWalletPortfolio skill."""
-
-    async def test_wallet_portfolio_success(self):
-        """Test successful wallet portfolio fetch."""
-        mock_skill_store = MagicMock()
-
-        with (
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.fetch_wallet_balances"
-            ) as mock_balances,
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.fetch_net_worth"
-            ) as mock_net_worth,
-        ):
-            # Mock successful responses
-            mock_balances.return_value = {
-                "result": [
-                    {
-                        "token_address": "0x123",
-                        "symbol": "TEST",
-                        "name": "Test Token",
-                        "balance": "1000000000000000000",
-                        "balance_formatted": "1.0",
-                        "usd_value": 100,
-                    }
-                ]
-            }
-            mock_net_worth.return_value = {"result": {"total_networth_usd": 1000}}
-
-            tool = FetchWalletPortfolio(
-                name="fetch_wallet_portfolio",
-                description="Test description",
-                args_schema=MagicMock(),
-                api_key="test_key",
-                skill_store=mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            result = await tool._arun(address="0xAddress")
-
-            self.assertEqual(result.address, "0xAddress")
-            self.assertEqual(result.total_net_worth, 1000)
-            self.assertEqual(len(result.tokens), 1)
-            self.assertEqual(result.tokens[0].symbol, "TEST")
-
-    async def test_wallet_portfolio_with_solana(self):
-        """Test wallet portfolio with Solana support."""
-        mock_skill_store = MagicMock()
-
-        with (
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.fetch_wallet_balances"
-            ) as mock_evm_balances,
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.fetch_net_worth"
-            ) as mock_net_worth,
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.get_solana_portfolio"
-            ) as mock_sol_portfolio,
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.get_token_price"
-            ) as mock_token_price,
-        ):
-            # Mock EVM responses
-            mock_evm_balances.return_value = {
-                "result": [
-                    {
-                        "token_address": "0x123",
-                        "symbol": "ETH",
-                        "name": "Ethereum",
-                        "balance": "1000000000000000000",
-                        "balance_formatted": "1.0",
-                        "usd_value": 2000,
-                    }
-                ]
-            }
-            mock_net_worth.return_value = {"result": {"total_networth_usd": 3000}}
-
-            # Mock Solana responses
-            mock_sol_portfolio.return_value = {
-                "nativeBalance": {"solana": 2.0, "lamports": 2000000000},
-                "tokens": [
-                    {
-                        "symbol": "SOL",
-                        "name": "Solana",
-                        "mint": "So11111111111111111111111111111111111111112",
-                        "associatedTokenAddress": "AssocTokenAddress",
-                        "amount": 2.0,
-                        "decimals": 9,
-                        "amountRaw": "2000000000",
-                    }
-                ],
-            }
-
-            mock_token_price.return_value = {"usdPrice": 500}
-
-            tool = FetchWalletPortfolio(
-                name="fetch_wallet_portfolio",
-                description="Test description",
-                args_schema=MagicMock(),
-                api_key="test_key",
-                skill_store=mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            result = await tool._arun(address="0xAddress", include_solana=True)
-
-            self.assertEqual(result.address, "0xAddress")
-            self.assertEqual(
-                result.total_net_worth, 3000
-            )  # Using the net worth from mock
-            self.assertIn("eth", result.chains)
-            self.assertIn("solana", result.chains)
-
-            # Check that we have both EVM and Solana tokens
-            token_symbols = [token.symbol for token in result.tokens]
-            self.assertIn("ETH", token_symbols)
-            self.assertIn("SOL", token_symbols)
-
-
-class TestFetchSolanaPortfolio(unittest.IsolatedAsyncioTestCase):
-    """Test the FetchSolanaPortfolio skill."""
-
-    async def test_solana_portfolio_success(self):
-        """Test successful Solana portfolio fetch."""
-        mock_skill_store = MagicMock()
-
-        with (
-            patch(
-                "skills.moralis.moralis_fetch_solana_portfolio.get_solana_portfolio"
-            ) as mock_portfolio,
-            patch(
-                "skills.moralis.moralis_fetch_solana_portfolio.get_solana_nfts"
-            ) as mock_nfts,
-            patch(
-                "skills.moralis.moralis_fetch_solana_portfolio.get_token_price"
-            ) as mock_token_price,
-        ):
-            # Mock successful responses
-            mock_portfolio.return_value = {
-                "nativeBalance": {"solana": 1.5, "lamports": 1500000000},
-                "tokens": [
-                    {
-                        "symbol": "TEST",
-                        "name": "Test Token",
-                        "mint": "TokenMintAddress",
-                        "associatedTokenAddress": "AssocTokenAddress",
-                        "amount": 10,
-                        "decimals": 9,
-                        "amountRaw": "10000000000",
-                    }
-                ],
-            }
-
-            mock_nfts.return_value = [
-                {
-                    "mint": "NFTMintAddress",
-                    "name": "Test NFT",
-                    "symbol": "TNFT",
-                    "associatedTokenAddress": "AssocTokenAddress",
-                    "metadata": {"name": "Test NFT", "image": "image.png"},
-                }
-            ]
-
-            mock_token_price.return_value = {"usdPrice": 25}
-
-            tool = FetchSolanaPortfolio(
-                name="fetch_solana_portfolio",
-                description="Test description",
-                args_schema=MagicMock(),
-                api_key="test_key",
-                skill_store=mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            result = await tool._arun(address="SolanaAddress", include_nfts=True)
-
-            self.assertEqual(result.address, "SolanaAddress")
-            self.assertEqual(result.sol_balance, 1.5)
-            self.assertEqual(len(result.tokens), 1)
-            self.assertEqual(result.tokens[0].token_info.symbol, "TEST")
-            self.assertEqual(len(result.nfts), 1)
-            self.assertEqual(result.nfts[0].name, "Test NFT")
-            self.assertEqual(result.sol_price_usd, 25)
-            self.assertEqual(result.sol_value_usd, 37.5)  # 1.5 SOL * $25
-
-
-class TestFetchChainPortfolio(unittest.IsolatedAsyncioTestCase):
-    """Test the FetchChainPortfolio skill."""
-
-    async def test_chain_portfolio_success(self):
-        """Test successful chain portfolio fetch."""
-        mock_skill_store = MagicMock()
-
-        with patch(
-            "skills.moralis.moralis_fetch_chain_portfolio.fetch_wallet_balances"
-        ) as mock_balances:
-            # Mock successful responses
-            mock_balances.return_value = {
-                "result": [
-                    {
-                        "token_address": "0x123",
-                        "symbol": "ETH",
-                        "name": "Ethereum",
-                        "logo": "logo.png",
-                        "decimals": 18,
-                        "balance": "1000000000000000000",
-                        "balance_formatted": "1.0",
-                        "usd_value": 2000,
-                        "native_token": True,
-                    },
-                    {
-                        "token_address": "0x456",
-                        "symbol": "TOKEN",
-                        "name": "Test Token",
-                        "logo": "logo2.png",
-                        "decimals": 18,
-                        "balance": "2000000000000000000",
-                        "balance_formatted": "2.0",
-                        "usd_value": 200,
-                        "native_token": False,
-                    },
-                ]
-            }
-
-            tool = FetchChainPortfolio(
-                name="fetch_chain_portfolio",
-                description="Test description",
-                args_schema=MagicMock(),
-                api_key="test_key",
-                skill_store=mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            result = await tool._arun(address="0xAddress", chain_id=1)
-
-            self.assertEqual(result.address, "0xAddress")
-            self.assertEqual(result.chain_id, 1)
-            self.assertEqual(result.chain_name, "eth")
-            self.assertEqual(result.total_usd_value, 2200)  # 2000 + 200
-            self.assertEqual(len(result.tokens), 1)  # Regular tokens, not native
-            self.assertIsNotNone(result.native_token)
-            self.assertEqual(result.native_token.symbol, "ETH")
-            self.assertEqual(result.tokens[0].symbol, "TOKEN")
-
-
-class TestSkillInitialization(unittest.TestCase):
-    """Test skill initialization and configuration."""
-
-    def setUp(self):
-        self.mock_skill_store = MagicMock()
-
-    def test_get_skills(self):
-        """Test getting multiple skills from config."""
-        config = {
-            "api_key": "test_api_key",
-            "states": {
-                "fetch_wallet_portfolio": "public",
-                "fetch_chain_portfolio": "public",
-                "fetch_nft_portfolio": "private",
-                "fetch_transaction_history": "private",
-                "fetch_solana_portfolio": "public",
-            },
-            "supported_chains": {"evm": True, "solana": True},
-        }
-
-        # Test with mock implementation
-        with patch("skills.moralis.base.WalletBaseTool") as mock_tool:
-            mock_tool.return_value = MagicMock()
-
-            # This is just a test structure - actual implementation would create the skills
-            skills = get_skills(
-                config,
-                is_private=False,  # Only get public skills
-                skill_store=self.mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            # In a real implementation, we'd test that the correct skills were returned
-            # For now, we just verify the function exists
-            self.assertIsNotNone(skills)
-
-
-class TestIntegration(unittest.TestCase):
-    """Integration tests for wallet skills."""
-
-    def test_wallet_skill_configuration(self):
-        """Test wallet skill configuration in agent config."""
-        # Example agent configuration
-        agent_config = {
-            "id": "crypto-agent",
-            "skills": {
-                "moralis": {
-                    "api_key": "test_api_key",
-                    "states": {
-                        "fetch_wallet_portfolio": "public",
-                        "fetch_chain_portfolio": "public",
-                        "fetch_nft_portfolio": "private",
-                        "fetch_transaction_history": "private",
-                        "fetch_solana_portfolio": "public",
-                    },
-                    "supported_chains": {"evm": True, "solana": True},
-                }
-            },
-        }
-
-        # Verify the configuration structure is valid
-        moralis_config = agent_config["skills"]["moralis"]
-        self.assertIn("api_key", moralis_config)
-        self.assertIn("states", moralis_config)
-        self.assertIn("supported_chains", moralis_config)
-
-        # Check that all required skills are configured
-        states = moralis_config["states"]
-        required_skills = [
-            "fetch_wallet_portfolio",
-            "fetch_chain_portfolio",
-            "fetch_nft_portfolio",
-            "fetch_transaction_history",
-            "fetch_solana_portfolio",
-        ]
-
-        for skill in required_skills:
-            self.assertIn(skill, states)
-            self.assertIn(states[skill], ["public", "private", "disabled"])
-
-        # Check chain configuration
-        chains = moralis_config["supported_chains"]
-        self.assertIn("evm", chains)
-        self.assertIn("solana", chains)
-        self.assertTrue(isinstance(chains["evm"], bool))
-        self.assertTrue(isinstance(chains["solana"], bool))
-
-
-if __name__ == "__main__":
-    unittest.main()