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

intentkit/models/generator.py

@@ -1,347 +0,0 @@
-"""Agent Generation Log Model.
-
-This module defines the database models for logging agent generation operations,
-including token usage, prompts, AI responses, and generation metadata.
-"""
-
-from datetime import datetime, timezone
-from typing import Annotated, Optional
-
-from epyxid import XID
-from intentkit.models.base import Base
-from pydantic import BaseModel, ConfigDict, Field
-from sqlalchemy import (
-    Boolean,
-    Column,
-    DateTime,
-    Integer,
-    String,
-    Text,
-    func,
-    select,
-)
-from sqlalchemy.dialects.postgresql import JSON, JSONB
-from sqlalchemy.ext.asyncio import AsyncSession
-
-
-class AgentGenerationLogTable(Base):
-    """Agent generation log database table model."""
-
-    __tablename__ = "agent_generation_logs"
-
-    id = Column(
-        String,
-        primary_key=True,
-    )
-    user_id = Column(
-        String,
-        nullable=True,
-    )
-    prompt = Column(
-        Text,
-        nullable=False,
-    )
-    existing_agent_id = Column(
-        String,
-        nullable=True,
-    )
-    is_update = Column(
-        Boolean,
-        default=False,
-        nullable=False,
-    )
-    generated_agent_schema = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
-        nullable=True,
-    )
-    identified_skills = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
-        nullable=True,
-    )
-    # LLM API response data
-    llm_model = Column(
-        String,
-        nullable=True,
-    )
-    total_tokens = Column(
-        Integer,
-        default=0,
-    )
-    input_tokens = Column(
-        Integer,
-        default=0,
-    )
-    cached_input_tokens = Column(
-        Integer,
-        default=0,
-    )
-    output_tokens = Column(
-        Integer,
-        default=0,
-    )
-    input_tokens_details = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
-        nullable=True,
-    )
-    completion_tokens_details = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
-        nullable=True,
-    )
-    # Performance metrics
-    generation_time_ms = Column(
-        Integer,
-        nullable=True,
-    )
-    retry_count = Column(
-        Integer,
-        default=0,
-    )
-    validation_errors = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
-        nullable=True,
-    )
-    # Status and results
-    success = Column(
-        Boolean,
-        default=False,
-        nullable=False,
-    )
-    error_message = Column(
-        Text,
-        nullable=True,
-    )
-    # Timestamps
-    created_at = Column(
-        DateTime(timezone=True),
-        nullable=False,
-        server_default=func.now(),
-    )
-    completed_at = Column(
-        DateTime(timezone=True),
-        nullable=True,
-    )
-
-
-class AgentGenerationLogCreate(BaseModel):
-    """Model for creating agent generation log entries."""
-
-    model_config = ConfigDict(
-        use_enum_values=True,
-        from_attributes=True,
-    )
-
-    id: Annotated[
-        str,
-        Field(
-            default_factory=lambda: str(XID()),
-            description="Unique identifier for the generation log",
-        ),
-    ]
-    user_id: Optional[str] = Field(
-        None,
-        description="User ID who initiated the generation",
-    )
-    prompt: str = Field(
-        ...,
-        description="The original prompt used for generation",
-    )
-    existing_agent_id: Optional[str] = Field(
-        None,
-        description="ID of existing agent if this is an update operation",
-    )
-    is_update: bool = Field(
-        False,
-        description="Whether this is an update to existing agent",
-    )
-
-
-class AgentGenerationLog(BaseModel):
-    """Agent generation log model."""
-
-    model_config = ConfigDict(
-        use_enum_values=True,
-        from_attributes=True,
-    )
-
-    id: str
-    user_id: Optional[str] = None
-    prompt: str
-    existing_agent_id: Optional[str] = None
-    is_update: bool = False
-    generated_agent_schema: Optional[dict] = None
-    identified_skills: Optional[dict] = None
-    llm_model: Optional[str] = None
-    total_tokens: int = 0
-    input_tokens: int = 0
-    cached_input_tokens: int = 0
-    output_tokens: int = 0
-    input_tokens_details: Optional[dict] = None
-    completion_tokens_details: Optional[dict] = None
-    generation_time_ms: Optional[int] = None
-    retry_count: int = 0
-    validation_errors: Optional[dict] = None
-    success: bool = False
-    error_message: Optional[str] = None
-    created_at: datetime
-    completed_at: Optional[datetime] = None
-
-    @classmethod
-    async def create(
-        cls,
-        session: AsyncSession,
-        log_data: AgentGenerationLogCreate,
-    ) -> "AgentGenerationLog":
-        """Create a new agent generation log entry.
-
-        Args:
-            session: Database session
-            log_data: Log data to create
-
-        Returns:
-            Created log instance
-        """
-        # Create database record
-        log_record = AgentGenerationLogTable(
-            id=log_data.id,
-            user_id=log_data.user_id,
-            prompt=log_data.prompt,
-            existing_agent_id=log_data.existing_agent_id,
-            is_update=log_data.is_update,
-        )
-
-        session.add(log_record)
-        await session.commit()
-        await session.refresh(log_record)
-
-        return cls.model_validate(log_record)
-
-    async def update_completion(
-        self,
-        session: AsyncSession,
-        generated_agent_schema: Optional[dict] = None,
-        identified_skills: Optional[dict] = None,
-        llm_model: Optional[str] = None,
-        total_tokens: int = 0,
-        input_tokens: int = 0,
-        cached_input_tokens: int = 0,
-        output_tokens: int = 0,
-        input_tokens_details: Optional[dict] = None,
-        completion_tokens_details: Optional[dict] = None,
-        generation_time_ms: Optional[int] = None,
-        retry_count: int = 0,
-        validation_errors: Optional[dict] = None,
-        success: bool = False,
-        error_message: Optional[str] = None,
-    ) -> None:
-        """Update the log entry with completion data.
-
-        Args:
-            session: Database session
-            generated_agent_schema: The generated agent schema
-            identified_skills: Skills identified during generation
-            llm_model: LLM model used
-            total_tokens: Total tokens used
-            input_tokens: Input tokens used
-            cached_input_tokens: Cached input tokens used (for cost calculation)
-            output_tokens: Output tokens used
-            input_tokens_details: Detailed input token breakdown
-            completion_tokens_details: Detailed completion token breakdown
-            generation_time_ms: Generation time in milliseconds
-            retry_count: Number of retries attempted
-            validation_errors: Any validation errors encountered
-            success: Whether generation was successful
-            error_message: Error message if generation failed
-        """
-        # Get the database record
-        log_record = await session.get(AgentGenerationLogTable, self.id)
-        if not log_record:
-            return
-
-        # Update fields
-        log_record.generated_agent_schema = generated_agent_schema
-        log_record.identified_skills = identified_skills
-        log_record.llm_model = llm_model
-        log_record.total_tokens = total_tokens
-        log_record.input_tokens = input_tokens
-        log_record.cached_input_tokens = cached_input_tokens
-        log_record.output_tokens = output_tokens
-        log_record.input_tokens_details = input_tokens_details
-        log_record.completion_tokens_details = completion_tokens_details
-        log_record.generation_time_ms = generation_time_ms
-        log_record.retry_count = retry_count
-        log_record.validation_errors = validation_errors
-        log_record.success = success
-        log_record.error_message = error_message
-        log_record.completed_at = datetime.now(timezone.utc)
-
-        session.add(log_record)
-        await session.commit()
-        await session.refresh(log_record)
-
-        # Update this instance
-        self.generated_agent_schema = log_record.generated_agent_schema
-        self.identified_skills = log_record.identified_skills
-        self.llm_model = log_record.llm_model
-        self.total_tokens = log_record.total_tokens
-        self.input_tokens = log_record.input_tokens
-        self.cached_input_tokens = log_record.cached_input_tokens
-        self.output_tokens = log_record.output_tokens
-        self.input_tokens_details = log_record.input_tokens_details
-        self.completion_tokens_details = log_record.completion_tokens_details
-        self.generation_time_ms = log_record.generation_time_ms
-        self.retry_count = log_record.retry_count
-        self.validation_errors = log_record.validation_errors
-        self.success = log_record.success
-        self.error_message = log_record.error_message
-        self.completed_at = log_record.completed_at
-
-    @classmethod
-    async def get_by_id(
-        cls,
-        session: AsyncSession,
-        log_id: str,
-    ) -> Optional["AgentGenerationLog"]:
-        """Get an agent generation log by ID.
-
-        Args:
-            session: Database session
-            log_id: Log ID
-
-        Returns:
-            Log instance if found, None otherwise
-        """
-        result = await session.execute(
-            select(AgentGenerationLogTable).where(AgentGenerationLogTable.id == log_id)
-        )
-        log_record = result.scalar_one_or_none()
-
-        if log_record:
-            return cls.model_validate(log_record)
-        return None
-
-    @classmethod
-    async def get_by_user(
-        cls,
-        session: AsyncSession,
-        user_id: str,
-        limit: int = 50,
-    ) -> list["AgentGenerationLog"]:
-        """Get agent generation logs for a user.
-
-        Args:
-            session: Database session
-            user_id: User ID
-            limit: Maximum number of logs to return
-
-        Returns:
-            List of log instances
-        """
-        result = await session.execute(
-            select(AgentGenerationLogTable)
-            .where(AgentGenerationLogTable.user_id == user_id)
-            .order_by(AgentGenerationLogTable.created_at.desc())
-            .limit(limit)
-        )
-        log_records = result.scalars().all()
-
-        return [cls.model_validate(record) for record in log_records]

intentkit/skills/cdp/get_balance.py

@@ -1,110 +0,0 @@
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.clients import get_cdp_client
-from intentkit.skills.cdp.base import CDPBaseTool
-
-
-class GetBalanceInput(BaseModel):
-    """Input for GetBalance tool."""
-
-    asset_id: Optional[str] = Field(
-        default=None,
-        description="The asset ID to get the balance for (e.g., 'eth', 'usdc', or a valid contract address). If not provided, returns all token balances.",
-    )
-
-
-class GetBalance(CDPBaseTool):
-    """Tool for getting balance from CDP wallet.
-
-    This tool uses the CDP API to get balance for all addresses in a wallet for a given asset.
-
-    Attributes:
-        name: The name of the tool.
-        description: A description of what the tool does.
-        args_schema: The schema for the tool's input arguments.
-    """
-
-    agent_id: str
-    skill_store: SkillStoreABC
-
-    name: str = "cdp_get_balance"
-    description: str = (
-        "This tool will get the balance of all the addresses in the wallet. If asset_id is provided, it returns the balance for that specific asset. "
-        "If no asset_id is provided, it returns all token balances. "
-        "Always use 'eth' for the native asset ETH and 'usdc' for USDC. "
-        "Other valid asset IDs are: weth,dai,reth,brett,w,cbeth,axl,iotx,prime,aero,rsr,mog,tbtc,npc,yfi"
-    )
-    args_schema: Type[BaseModel] = GetBalanceInput
-
-    async def _arun(self, asset_id: Optional[str] = None) -> str:
-        """Async implementation of the tool to get balance.
-
-        Args:
-            asset_id (Optional[str]): The asset ID to get the balance for. If None, returns all token balances.
-
-        Returns:
-            str: A message containing the balance information or error message.
-        """
-        # Get network information from CDP client
-        cdp_client = await get_cdp_client(self.agent_id, self.skill_store)
-        provider = await cdp_client.get_wallet_provider()
-        provider_config = await cdp_client.get_provider_config()
-        network_id = provider_config.network_id
-
-        # Map network_id to the format expected by the API
-        network_mapping = {
-            "base-mainnet": "base",
-            "ethereum-mainnet": "ethereum",
-        }
-        api_network = network_mapping.get(network_id, network_id)
-
-        # For native ETH balance, use the account's balance directly
-        if asset_id and asset_id.lower() == "eth":
-            try:
-                # Get native balance using Web3
-                balance_wei = provider.get_balance()
-                balance_eth = balance_wei / (10**18)  # Convert from wei to ETH
-                return f"ETH balance: {balance_eth} ETH"
-            except Exception as e:
-                return f"Error getting ETH balance: {e!s}"
-
-        client = provider.get_client()
-        async with client:
-            account = await client.evm.get_account(provider.get_address())
-            # If no asset_id provided, return all token balances
-            if asset_id is None:
-                # Get native ETH balance
-                balance_wei = provider.get_balance()
-                balance_eth = balance_wei / (10**18)  # Convert from wei to ETH
-
-                # Get all token balances
-                token_balances = await account.list_token_balances(api_network)
-
-                result = [f"ETH balance: {balance_eth} ETH"]
-
-                for balance in token_balances.balances:
-                    result.append(
-                        f"{balance.token.symbol} balance: {balance.amount.decimals} {balance.token.name}"
-                    )
-
-                return f"All balances for account {account.address}:\n" + "\n".join(
-                    result
-                )
-
-            # For other tokens, try the list_token_balances API
-            token_balances = await account.list_token_balances(api_network)
-
-            # Find the balance for the specific asset
-            target_balance = None
-            for balance in token_balances.balances:
-                if balance.token.symbol.lower() == asset_id.lower():
-                    target_balance = balance
-                    break
-
-            if target_balance:
-                return f"Balance for {asset_id} in account {account.address}: {target_balance.amount.decimals} {target_balance.token.name}"
-            else:
-                return f"No balance found for asset {asset_id} in account {account.address}"

intentkit/skills/cdp/swap.py

@@ -1,121 +0,0 @@
-from typing import Optional, Type, Union
-
-from pydantic import BaseModel, Field
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.clients import get_cdp_client
-from intentkit.skills.cdp.base import CDPBaseTool
-
-
-class SwapInput(BaseModel):
-    """Input for Swap tool."""
-
-    from_token: str = Field(
-        description="The contract address of the token to swap from (e.g., '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' for USDC on Base)"
-    )
-    to_token: str = Field(
-        description="The contract address of the token to swap to (e.g., '0x4200000000000000000000000000000000000006' for WETH on Base)"
-    )
-    from_amount: Union[str, int] = Field(
-        description="The amount to swap from in smallest unit (e.g., 1000000 for 1 USDC with 6 decimals)"
-    )
-    slippage_bps: Optional[int] = Field(
-        default=100,
-        description="Maximum slippage in basis points (100 = 1%). Defaults to 100 (1%)",
-    )
-
-
-class Swap(CDPBaseTool):
-    """Tool for swapping tokens using CDP wallet.
-
-    This tool uses the CDP API to execute token swaps on supported networks.
-    It wraps the swap functionality from the EVM account.
-
-    Attributes:
-        name: The name of the tool.
-        description: A description of what the tool does.
-        args_schema: The schema for the tool's input arguments.
-    """
-
-    agent_id: str
-    skill_store: SkillStoreABC
-
-    name: str = "cdp_swap"
-    description: str = (
-        "This tool will swap tokens using the CDP wallet. "
-        "It supports swapping between any ERC-20 tokens on supported networks (Base and Ethereum). "
-        "You need to provide the contract addresses of both tokens and the amount to swap. "
-        "The amount should be in the smallest unit of the token (e.g., wei for ETH, or atomic units for ERC-20 tokens). "
-        "Common token addresses on Base: USDC=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, WETH=0x4200000000000000000000000000000000000006. "
-        "The tool will automatically handle gas estimation and transaction submission."
-    )
-    args_schema: Type[BaseModel] = SwapInput
-
-    async def _arun(
-        self,
-        from_token: str,
-        to_token: str,
-        from_amount: Union[str, int],
-        slippage_bps: Optional[int] = 100,
-    ) -> str:
-        """Async implementation of the tool to swap tokens.
-
-        Args:
-            from_token (str): The contract address of the token to swap from.
-            to_token (str): The contract address of the token to swap to.
-            from_amount (Union[str, int]): The amount to swap from in smallest unit.
-            slippage_bps (Optional[int]): Maximum slippage in basis points. Defaults to 100 (1%).
-
-        Returns:
-            str: A message containing the swap result or error message.
-        """
-        try:
-            # Get CDP client and network information
-            cdp_client = await get_cdp_client(self.agent_id, self.skill_store)
-            provider = await cdp_client.get_wallet_provider()
-            provider_config = await cdp_client.get_provider_config()
-            network_id = provider_config.network_id
-
-            # Map network_id to the format expected by the swap API
-            network_mapping = {
-                "base-mainnet": "base",
-                "ethereum-mainnet": "ethereum",
-            }
-            api_network = network_mapping.get(network_id, network_id)
-
-            # Validate network is supported
-            supported_networks = ["base", "ethereum"]
-            if api_network not in supported_networks:
-                return f"Error: Network {api_network} is not supported for swaps. Supported networks: {', '.join(supported_networks)}"
-
-            # Get the EVM account
-            client = provider.get_client()
-            async with client:
-                account = await client.evm.get_account(provider.get_address())
-
-                # Import AccountSwapOptions here to avoid circular imports
-                from cdp.actions.evm.swap.types import AccountSwapOptions
-
-                # Create swap options
-                swap_options = AccountSwapOptions(
-                    network=api_network,
-                    from_token=from_token,
-                    to_token=to_token,
-                    from_amount=str(from_amount),
-                    slippage_bps=slippage_bps,
-                )
-
-                # Execute the swap
-                result = await account.swap(swap_options)
-
-                return (
-                    f"Swap executed successfully!\n"
-                    f"Transaction hash: {result.transaction_hash}\n"
-                    f"Swapped from {from_token} to {to_token}\n"
-                    f"Amount: {from_amount} (smallest units)\n"
-                    f"Network: {api_network}\n"
-                    f"Slippage tolerance: {slippage_bps} basis points ({slippage_bps / 100 if slippage_bps else 0}%)"
-                )
-
-        except Exception as e:
-            return f"Error executing swap: {e!s}"