intentkit 0.8.11__tar.gz → 0.8.12__tar.gz

{intentkit-0.8.11 → intentkit-0.8.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.8.11
+Version: 0.8.12
 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.8.11 → intentkit-0.8.12}/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.8.11"
+__version__ = "0.8.12"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

{intentkit-0.8.11 → intentkit-0.8.12}/abstracts/graph.py

@@ -41,3 +41,7 @@ class AgentContext(BaseModel):
     @property
     def agent(self) -> Agent:
         return self.get_agent()
+
+    @property
+    def thread_id(self) -> str:
+        return f"{self.agent_id}-{self.chat_id}"

intentkit-0.8.12/abstracts/skill.py

@@ -0,0 +1,60 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData, AgentQuota
+
+
+class SkillStoreABC(ABC):
+    """Abstract base class for skill data storage operations.
+
+    This class defines the interface for interacting with skill-related data
+    for both agents and threads.
+    """
+
+    @staticmethod
+    @abstractmethod
+    def get_system_config(key: str) -> Any:
+        """Get system configuration value by key."""
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def get_agent_config(agent_id: str) -> Optional[Agent]:
+        """Get agent configuration.
+
+        Returns:
+            Agent configuration if found, None otherwise
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def get_agent_data(agent_id: str) -> Optional[AgentData]:
+        """Get additional agent data.
+
+        Returns:
+            Agent data if found, None otherwise
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def set_agent_data(agent_id: str, data: Dict) -> None:
+        """Update agent data.
+
+        Args:
+            agent_id: ID of the agent
+            data: Dictionary containing fields to update
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    async def get_agent_quota(agent_id: str) -> Optional[AgentQuota]:
+        """Get agent quota information.
+
+        Returns:
+            Agent quota if found, None otherwise
+        """
+        pass

{intentkit-0.8.11 → intentkit-0.8.12}/clients/twitter.py

@@ -11,7 +11,6 @@ from requests.auth import HTTPBasicAuth
 from requests_oauthlib import OAuth2Session
 from tweepy.asynchronous import AsyncClient
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.abstracts.twitter import TwitterABC
 from intentkit.models.agent_data import AgentData
 from intentkit.models.redis import get_redis
@@ -80,33 +79,44 @@ class TwitterClient(TwitterABC):
 
     Args:
         agent_id: The ID of the agent
-        skill_store: The skill store for retrieving data
         config: Configuration dictionary that may contain API keys
     """
 
-    def __init__(self, agent_id: str, skill_store: SkillStoreABC, config: Dict) -> None:
+    def __init__(self, agent_id: str, config: Dict) -> None:
         """Initialize the Twitter client.
 
         Args:
             agent_id: The ID of the agent
-            skill_store: The skill store for retrieving data
             config: Configuration dictionary that may contain API keys
         """
         self.agent_id = agent_id
         self._client: Optional[AsyncClient] = None
-        self._skill_store = skill_store
         self._agent_data: Optional[AgentData] = None
         self.use_key = _is_self_key(config)
         self._config = config
 
+    async def _get_agent_data(self) -> AgentData:
+        """Retrieve cached agent data, loading from the database if needed."""
+
+        if not self._agent_data:
+            self._agent_data = await AgentData.get(self.agent_id)
+        return self._agent_data
+
+    async def _refresh_agent_data(self) -> AgentData:
+        """Reload agent data from the database."""
+
+        self._agent_data = await AgentData.get(self.agent_id)
+        return self._agent_data
+
     async def get_client(self) -> AsyncClient:
         """Get the initialized Twitter client.
 
         Returns:
             AsyncClient: The Twitter client if initialized
         """
-        if not self._agent_data:
-            self._agent_data = await self._skill_store.get_agent_data(self.agent_id)
+
+        agent_data = await self._get_agent_data()
+
         if not self._client:
             # Check if we have API keys in config
             if self.use_key:
@@ -118,8 +128,8 @@ class TwitterClient(TwitterABC):
                     return_type=dict,
                 )
                 # refresh userinfo if needed
-                if not self._agent_data.twitter_self_key_refreshed_at or (
-                    self._agent_data.twitter_self_key_refreshed_at
+                if not agent_data.twitter_self_key_refreshed_at or (
+                    agent_data.twitter_self_key_refreshed_at
                     < datetime.now(tz=timezone.utc) - timedelta(days=1)
                 ):
                     me = await self._client.get_me(
@@ -127,7 +137,7 @@ class TwitterClient(TwitterABC):
                         user_fields="id,username,name,verified",
                     )
                     if me and "data" in me and "id" in me["data"]:
-                        await self._skill_store.set_agent_data(
+                        await AgentData.patch(
                             self.agent_id,
                             {
                                 "twitter_id": me["data"]["id"],
@@ -139,9 +149,7 @@ class TwitterClient(TwitterABC):
                                 ),
                             },
                         )
-                    self._agent_data = await self._skill_store.get_agent_data(
-                        self.agent_id
-                    )
+                    agent_data = await self._refresh_agent_data()
                 logger.info(
                     f"Twitter self key client initialized. "
                     f"Use API key: {self.use_key}, "
@@ -152,39 +160,40 @@ class TwitterClient(TwitterABC):
                 )
                 return self._client
             # Otherwise try to get OAuth2 tokens from agent data
-            if not self._agent_data.twitter_access_token:
+            if not agent_data.twitter_access_token:
                 raise Exception(f"[{self.agent_id}] Twitter access token not found")
-            if not self._agent_data.twitter_access_token_expires_at:
+            if not agent_data.twitter_access_token_expires_at:
                 raise Exception(
                     f"[{self.agent_id}] Twitter access token expiration not found"
                 )
-            if self._agent_data.twitter_access_token_expires_at <= datetime.now(
+            if agent_data.twitter_access_token_expires_at <= datetime.now(
                 tz=timezone.utc
             ):
                 raise Exception(f"[{self.agent_id}] Twitter access token has expired")
             self._client = AsyncClient(
-                bearer_token=self._agent_data.twitter_access_token,
+                bearer_token=agent_data.twitter_access_token,
                 return_type=dict,
             )
             return self._client
+
         if not self.use_key:
             # check if access token has expired
-            if self._agent_data.twitter_access_token_expires_at <= datetime.now(
+            if agent_data.twitter_access_token_expires_at <= datetime.now(
                 tz=timezone.utc
             ):
-                self._agent_data = await self._skill_store.get_agent_data(self.agent_id)
-                # check again
-                if self._agent_data.twitter_access_token_expires_at <= datetime.now(
+                agent_data = await self._refresh_agent_data()
+                if agent_data.twitter_access_token_expires_at <= datetime.now(
                     tz=timezone.utc
                 ):
                     raise Exception(
                         f"[{self.agent_id}] Twitter access token has expired"
                     )
                 self._client = AsyncClient(
-                    bearer_token=self._agent_data.twitter_access_token,
+                    bearer_token=agent_data.twitter_access_token,
                     return_type=dict,
                 )
                 return self._client
+
         return self._client
 
     @property
@@ -352,7 +361,7 @@ class TwitterClient(TwitterABC):
             ValueError: If there's an error uploading the media.
         """
         # Get agent data to access the token
-        agent_data = await self._skill_store.get_agent_data(agent_id)
+        agent_data = await AgentData.get(agent_id)
         if not agent_data.twitter_access_token:
             raise ValueError("Only linked X account can post media")
 
@@ -423,15 +432,13 @@ def _is_self_key(config: Dict) -> bool:
     return config.get("api_key_provider") == "agent_owner"
 
 
-def get_twitter_client(
-    agent_id: str, skill_store: SkillStoreABC, config: Dict
-) -> "TwitterClient":
+def get_twitter_client(agent_id: str, config: Dict) -> "TwitterClient":
     if _is_self_key(config):
         if agent_id not in _clients_self_key:
-            _clients_self_key[agent_id] = TwitterClient(agent_id, skill_store, config)
+            _clients_self_key[agent_id] = TwitterClient(agent_id, config)
         return _clients_self_key[agent_id]
     if agent_id not in _clients_linked:
-        _clients_linked[agent_id] = TwitterClient(agent_id, skill_store, config)
+        _clients_linked[agent_id] = TwitterClient(agent_id, config)
     return _clients_linked[agent_id]
 
 

{intentkit-0.8.11 → intentkit-0.8.12}/core/agent.py

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