intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__py3-none-any.whl

intentkit/core/skill.py

@@ -1,200 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.config.config import config
-from intentkit.core.agent import (
-    add_autonomous_task as _add_autonomous_task,
-)
-from intentkit.core.agent import (
-    delete_autonomous_task as _delete_autonomous_task,
-)
-from intentkit.core.agent import (
-    list_autonomous_tasks as _list_autonomous_tasks,
-)
-from intentkit.core.agent import (
-    update_autonomous_task as _update_autonomous_task,
-)
-from intentkit.models.agent import Agent, AgentAutonomous
-from intentkit.models.agent_data import AgentData, AgentQuota
-from intentkit.models.skill import (
-    AgentSkillData,
-    AgentSkillDataCreate,
-    ThreadSkillData,
-    ThreadSkillDataCreate,
-)
-
-
-class SkillStore(SkillStoreABC):
-    """Implementation of skill data storage operations.
-
-    This class provides concrete implementations for storing and retrieving
-    skill-related data for both agents and threads.
-    """
-
-    @staticmethod
-    def get_system_config(key: str) -> Any:
-        # TODO: maybe need a whitelist here
-        if hasattr(config, key):
-            return getattr(config, key)
-        return None
-
-    @staticmethod
-    async def get_agent_config(agent_id: str) -> Optional[Agent]:
-        return await Agent.get(agent_id)
-
-    @staticmethod
-    async def get_agent_data(agent_id: str) -> AgentData:
-        return await AgentData.get(agent_id)
-
-    @staticmethod
-    async def set_agent_data(agent_id: str, data: Dict) -> AgentData:
-        return await AgentData.patch(agent_id, data)
-
-    @staticmethod
-    async def get_agent_quota(agent_id: str) -> AgentQuota:
-        return await AgentQuota.get(agent_id)
-
-    @staticmethod
-    async def get_agent_skill_data(
-        agent_id: str, skill: str, key: str
-    ) -> Optional[Dict[str, Any]]:
-        """Get skill data for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            skill: Name of the skill
-            key: Data key
-
-        Returns:
-            Dictionary containing the skill data if found, None otherwise
-        """
-        return await AgentSkillData.get(agent_id, skill, key)
-
-    @staticmethod
-    async def save_agent_skill_data(
-        agent_id: str, skill: str, key: str, data: Dict[str, Any]
-    ) -> None:
-        """Save or update skill data for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            skill: Name of the skill
-            key: Data key
-            data: JSON data to store
-        """
-        skill_data = AgentSkillDataCreate(
-            agent_id=agent_id,
-            skill=skill,
-            key=key,
-            data=data,
-        )
-        await skill_data.save()
-
-    @staticmethod
-    async def delete_agent_skill_data(agent_id: str, skill: str, key: str) -> None:
-        """Delete skill data for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            skill: Name of the skill
-            key: Data key
-        """
-        await AgentSkillData.delete(agent_id, skill, key)
-
-    @staticmethod
-    async def get_thread_skill_data(
-        thread_id: str, skill: str, key: str
-    ) -> Optional[Dict[str, Any]]:
-        """Get skill data for a thread.
-
-        Args:
-            thread_id: ID of the thread
-            skill: Name of the skill
-            key: Data key
-
-        Returns:
-            Dictionary containing the skill data if found, None otherwise
-        """
-        return await ThreadSkillData.get(thread_id, skill, key)
-
-    @staticmethod
-    async def save_thread_skill_data(
-        thread_id: str,
-        agent_id: str,
-        skill: str,
-        key: str,
-        data: Dict[str, Any],
-    ) -> None:
-        """Save or update skill data for a thread.
-
-        Args:
-            thread_id: ID of the thread
-            agent_id: ID of the agent that owns this thread
-            skill: Name of the skill
-            key: Data key
-            data: JSON data to store
-        """
-        skill_data = ThreadSkillDataCreate(
-            thread_id=thread_id,
-            agent_id=agent_id,
-            skill=skill,
-            key=key,
-            data=data,
-        )
-        await skill_data.save()
-
-    @staticmethod
-    async def list_autonomous_tasks(agent_id: str) -> List[AgentAutonomous]:
-        """List all autonomous tasks for an agent.
-
-        Args:
-            agent_id: ID of the agent
-
-        Returns:
-            List[AgentAutonomous]: List of autonomous task configurations
-        """
-        return await _list_autonomous_tasks(agent_id)
-
-    @staticmethod
-    async def add_autonomous_task(
-        agent_id: str, task: AgentAutonomous
-    ) -> AgentAutonomous:
-        """Add a new autonomous task to an agent.
-
-        Args:
-            agent_id: ID of the agent
-            task: Autonomous task configuration
-
-        Returns:
-            AgentAutonomous: The created task
-        """
-        return await _add_autonomous_task(agent_id, task)
-
-    @staticmethod
-    async def delete_autonomous_task(agent_id: str, task_id: str) -> None:
-        """Delete an autonomous task from an agent.
-
-        Args:
-            agent_id: ID of the agent
-            task_id: ID of the task to delete
-        """
-        await _delete_autonomous_task(agent_id, task_id)
-
-    @staticmethod
-    async def update_autonomous_task(
-        agent_id: str, task_id: str, task_updates: dict
-    ) -> AgentAutonomous:
-        """Update an autonomous task for an agent.
-
-        Args:
-            agent_id: ID of the agent
-            task_id: ID of the task to update
-            task_updates: Dictionary containing fields to update
-
-        Returns:
-            AgentAutonomous: The updated task
-        """
-        return await _update_autonomous_task(agent_id, task_id, task_updates)
-
-
-skill_store = SkillStore()

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}"