intentkit 0.8.11.dev1__tar.gz → 0.8.12.dev1__tar.gz

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

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

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

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/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.11.dev1 → intentkit-0.8.12.dev1}/abstracts/skill.py

@@ -59,87 +59,6 @@ class SkillStoreABC(ABC):
         """
         pass
 
-    @staticmethod
-    @abstractmethod
-    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
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    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
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    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
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    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
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    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
-        """
-        pass
-
     @staticmethod
     @abstractmethod
     async def list_autonomous_tasks(agent_id: str) -> List[AgentAutonomous]:

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

@@ -25,12 +25,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
 
@@ -522,95 +516,6 @@ class AgentStore(SkillStoreABC):
     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.

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/core/engine.py

@@ -21,6 +21,7 @@ from typing import Optional, Tuple
 
 import sqlalchemy
 from epyxid import XID
+from langchain.agents import create_agent as create_react_agent
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import (
     BaseMessage,
@@ -29,7 +30,6 @@ from langchain_core.messages import (
 from langchain_core.tools import BaseTool
 from langgraph.errors import GraphRecursionError
 from langgraph.graph.state import CompiledStateGraph
-from langgraph.prebuilt import create_react_agent
 from langgraph.runtime import Runtime
 from sqlalchemy import func, update
 from sqlalchemy.exc import SQLAlchemyError
@@ -56,7 +56,7 @@ from intentkit.models.chat import (
 from intentkit.models.credit import CreditAccount, OwnerType
 from intentkit.models.db import get_langgraph_checkpointer, get_session
 from intentkit.models.llm import LLMModelInfo, LLMProvider, create_llm_model
-from intentkit.models.skill import AgentSkillData, ThreadSkillData
+from intentkit.models.skill import AgentSkillData, ChatSkillData
 from intentkit.models.user import User
 from intentkit.utils.error import IntentKitAPIError
 
@@ -70,7 +70,9 @@ _agents: dict[str, CompiledStateGraph] = {}
 _agents_updated: dict[str, datetime] = {}
 
 
-async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph:
+async def build_agent(
+    agent: Agent, agent_data: AgentData, custom_skills: list[BaseTool] = []
+) -> CompiledStateGraph:
     """Build an AI agent with specified configuration and tools.
 
     This function:
@@ -82,7 +84,8 @@ async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph
     Args:
         agent (Agent): Agent configuration object
         agent_data (AgentData): Agent data object
-        is_private (bool, optional): Flag indicating whether the agent is private. Defaults to False.
+        custom_skills (list[BaseTool], optional): Designed for advanced user who directly
+            call this function to inject custom skills into the agent tool node.
 
     Returns:
         CompiledStateGraph: Initialized LangChain agent
@@ -127,6 +130,10 @@ async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph
             except ImportError as e:
                 logger.error(f"Could not import skill module: {k} ({e})")
 
+    # add custom skills to private tools
+    if custom_skills and len(custom_skills) > 0:
+        private_tools.extend(custom_skills)
+
     # filter the duplicate tools
     tools = list({tool.name: tool for tool in tools}.values())
     private_tools = list({tool.name: tool for tool in private_tools}.values())
@@ -889,7 +896,7 @@ async def clean_agent_memory(
 
         if clean_skill:
             await AgentSkillData.clean_data(agent_id)
-            await ThreadSkillData.clean_data(agent_id, chat_id)
+            await ChatSkillData.clean_data(agent_id, chat_id)
 
         async with get_session() as db:
             if clean_agent:

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/models/skill.py

@@ -213,12 +213,12 @@ class AgentSkillData(AgentSkillDataCreate):
             await db.commit()
 
 
-class ThreadSkillDataTable(Base):
-    """Database table model for storing skill-specific data for threads."""
+class ChatSkillDataTable(Base):
+    """Database table model for storing skill-specific data for chats."""
 
-    __tablename__ = "thread_skill_data"
+    __tablename__ = "chat_skill_data"
 
-    thread_id = Column(String, primary_key=True)
+    chat_id = Column(String, primary_key=True)
     skill = Column(String, primary_key=True)
     key = Column(String, primary_key=True)
     agent_id = Column(String, nullable=False)
@@ -236,31 +236,29 @@ class ThreadSkillDataTable(Base):
     )
 
 
-class ThreadSkillDataCreate(BaseModel):
-    """Base model for creating thread skill data records."""
+class ChatSkillDataCreate(BaseModel):
+    """Base model for creating chat skill data records."""
 
     model_config = ConfigDict(from_attributes=True)
 
-    thread_id: Annotated[
-        str, Field(description="ID of the thread this data belongs to")
-    ]
+    chat_id: Annotated[str, Field(description="ID of the chat this data belongs to")]
     skill: Annotated[str, Field(description="Name of the skill this data is for")]
     key: Annotated[str, Field(description="Key for this specific piece of data")]
-    agent_id: Annotated[str, Field(description="ID of the agent that owns this thread")]
+    agent_id: Annotated[str, Field(description="ID of the agent that owns this chat")]
     data: Annotated[Dict[str, Any], Field(description="JSON data stored for this key")]
 
-    async def save(self) -> "ThreadSkillData":
+    async def save(self) -> "ChatSkillData":
         """Save or update skill data.
 
         Returns:
-            ThreadSkillData: The saved thread skill data instance
+            ChatSkillData: The saved chat skill data instance
         """
         async with get_session() as db:
             record = await db.scalar(
-                select(ThreadSkillDataTable).where(
-                    ThreadSkillDataTable.thread_id == self.thread_id,
-                    ThreadSkillDataTable.skill == self.skill,
-                    ThreadSkillDataTable.key == self.key,
+                select(ChatSkillDataTable).where(
+                    ChatSkillDataTable.chat_id == self.chat_id,
+                    ChatSkillDataTable.skill == self.skill,
+                    ChatSkillDataTable.key == self.key,
                 )
             )
 
@@ -270,18 +268,18 @@ class ThreadSkillDataCreate(BaseModel):
                 record.agent_id = self.agent_id
             else:
                 # Create new record
-                record = ThreadSkillDataTable(**self.model_dump())
+                record = ChatSkillDataTable(**self.model_dump())
             db.add(record)
             await db.commit()
             await db.refresh(record)
-            return ThreadSkillData.model_validate(record)
+            return ChatSkillData.model_validate(record)
 
 
-class ThreadSkillData(ThreadSkillDataCreate):
-    """Model for storing skill-specific data for threads.
+class ChatSkillData(ChatSkillDataCreate):
+    """Model for storing skill-specific data for chats.
 
-    This model uses a composite primary key of (thread_id, skill, key) to store
-    skill-specific data for threads in a flexible way. It also includes agent_id
+    This model uses a composite primary key of (chat_id, skill, key) to store
+    skill-specific data for chats in a flexible way. It also includes agent_id
     as a required field for tracking ownership.
     """
 
@@ -298,11 +296,11 @@ class ThreadSkillData(ThreadSkillDataCreate):
     ]
 
     @classmethod
-    async def get(cls, thread_id: str, skill: str, key: str) -> Optional[dict]:
-        """Get skill data for a thread.
+    async def get(cls, chat_id: str, skill: str, key: str) -> Optional[dict]:
+        """Get skill data for a chat.
 
         Args:
-            thread_id: ID of the thread
+            chat_id: ID of the chat
             skill: Name of the skill
             key: Data key
 
@@ -311,10 +309,10 @@ class ThreadSkillData(ThreadSkillDataCreate):
         """
         async with get_session() as db:
             record = await db.scalar(
-                select(ThreadSkillDataTable).where(
-                    ThreadSkillDataTable.thread_id == thread_id,
-                    ThreadSkillDataTable.skill == skill,
-                    ThreadSkillDataTable.key == key,
+                select(ChatSkillDataTable).where(
+                    ChatSkillDataTable.chat_id == chat_id,
+                    ChatSkillDataTable.skill == skill,
+                    ChatSkillDataTable.key == key,
                 )
             )
         return record.data if record else None
@@ -323,33 +321,33 @@ class ThreadSkillData(ThreadSkillDataCreate):
     async def clean_data(
         cls,
         agent_id: str,
-        thread_id: Annotated[
+        chat_id: Annotated[
             str,
             Field(
                 default="",
-                description="Optional ID of the thread. If provided, only cleans data for that thread.",
+                description="Optional ID of the chat. If provided, only cleans data for that chat.",
             ),
         ],
     ):
-        """Clean all skill data for a thread or agent.
+        """Clean all skill data for a chat or agent.
 
         Args:
             agent_id: ID of the agent
-            thread_id: Optional ID of the thread. If provided, only cleans data for that thread.
-                      If empty, cleans all data for the agent.
+            chat_id: Optional ID of the chat. If provided, only cleans data for that chat.
+                     If empty, cleans all data for the agent.
         """
         async with get_session() as db:
-            if thread_id and thread_id != "":
+            if chat_id and chat_id != "":
                 await db.execute(
-                    delete(ThreadSkillDataTable).where(
-                        ThreadSkillDataTable.agent_id == agent_id,
-                        ThreadSkillDataTable.thread_id == thread_id,
+                    delete(ChatSkillDataTable).where(
+                        ChatSkillDataTable.agent_id == agent_id,
+                        ChatSkillDataTable.chat_id == chat_id,
                     )
                 )
             else:
                 await db.execute(
-                    delete(ThreadSkillDataTable).where(
-                        ThreadSkillDataTable.agent_id == agent_id
+                    delete(ChatSkillDataTable).where(
+                        ChatSkillDataTable.agent_id == agent_id
                     )
                 )
             await db.commit()

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.8.11-dev1"
+version = "0.8.12-dev1"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/skills/base.py

@@ -33,6 +33,12 @@ from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.clients import get_wallet_provider
 from intentkit.clients.web3 import get_web3_client
 from intentkit.models.redis import get_redis
+from intentkit.models.skill import (
+    AgentSkillData,
+    AgentSkillDataCreate,
+    ChatSkillData,
+    ChatSkillDataCreate,
+)
 from intentkit.utils.error import IntentKitAPIError, RateLimitExceeded
 
 if TYPE_CHECKING:
@@ -184,6 +190,67 @@ class IntentKitSkill(BaseTool):
 
         return get_web3_client(network_id)
 
+    async def get_agent_skill_data(
+        self,
+        key: str,
+    ) -> Optional[Dict[str, Any]]:
+        """Retrieve persisted data for this skill scoped to the active agent."""
+        return await self.get_agent_skill_data_raw(self.name, key)
+
+    async def get_agent_skill_data_raw(
+        self,
+        skill_name: str,
+        key: str,
+    ) -> Optional[Dict[str, Any]]:
+        """Retrieve persisted data for a specific skill scoped to the active agent."""
+        context = self.get_context()
+        return await AgentSkillData.get(context.agent_id, skill_name, key)
+
+    async def save_agent_skill_data(self, key: str, data: Dict[str, Any]) -> None:
+        """Persist data for this skill scoped to the active agent."""
+        await self.save_agent_skill_data_raw(self.name, key, data)
+
+    async def save_agent_skill_data_raw(
+        self,
+        skill_name: str,
+        key: str,
+        data: Dict[str, Any],
+    ) -> None:
+        """Persist data for a specific skill scoped to the active agent."""
+        context = self.get_context()
+        skill_data = AgentSkillDataCreate(
+            agent_id=context.agent_id,
+            skill=skill_name,
+            key=key,
+            data=data,
+        )
+        await skill_data.save()
+
+    async def delete_agent_skill_data(self, key: str) -> None:
+        """Remove persisted data for this skill scoped to the active agent."""
+        context = self.get_context()
+        await AgentSkillData.delete(context.agent_id, self.name, key)
+
+    async def get_thread_skill_data(
+        self,
+        key: str,
+    ) -> Optional[Dict[str, Any]]:
+        """Retrieve persisted data for this skill scoped to the active chat."""
+        context = self.get_context()
+        return await ChatSkillData.get(context.chat_id, self.name, key)
+
+    async def save_thread_skill_data(self, key: str, data: Dict[str, Any]) -> None:
+        """Persist data for this skill scoped to the active chat."""
+        context = self.get_context()
+        skill_data = ChatSkillDataCreate(
+            chat_id=context.chat_id,
+            agent_id=context.agent_id,
+            skill=self.name,
+            key=key,
+            data=data,
+        )
+        await skill_data.save()
+
 
 async def get_agentkit_actions(
     agent_id: str,

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/skills/casino/deck_draw.py

@@ -68,8 +68,8 @@ class CasinoDeckDraw(CasinoBaseTool):
             count = validate_card_count(count)
 
             # Get current deck info
-            deck_info = await self.skill_store.get_agent_skill_data(
-                context.agent_id, DECK_STORAGE_KEY, CURRENT_DECK_KEY
+            deck_info = await self.get_agent_skill_data_raw(
+                DECK_STORAGE_KEY, CURRENT_DECK_KEY
             )
 
             deck_id = "new"  # Default to new deck
@@ -99,8 +99,7 @@ class CasinoDeckDraw(CasinoBaseTool):
                         else:
                             deck_info["remaining"] = data["remaining"]
 
-                        await self.skill_store.save_agent_skill_data(
-                            context.agent_id,
+                        await self.save_agent_skill_data_raw(
                             DECK_STORAGE_KEY,
                             CURRENT_DECK_KEY,
                             deck_info,

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/skills/casino/deck_shuffle.py

@@ -95,8 +95,10 @@ class CasinoDeckShuffle(CasinoBaseTool):
                         "shuffled": data["shuffled"],
                     }
 
-                    await self.skill_store.save_agent_skill_data(
-                        context.agent_id, DECK_STORAGE_KEY, CURRENT_DECK_KEY, deck_info
+                    await self.save_agent_skill_data_raw(
+                        DECK_STORAGE_KEY,
+                        CURRENT_DECK_KEY,
+                        deck_info,
                     )
 
                     return {

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/skills/cryptocompare/base.py

@@ -36,22 +36,17 @@ class CryptoCompareBaseTool(IntentKitSkill):
     def category(self) -> str:
         return "cryptocompare"
 
-    async def check_rate_limit(
-        self, agent_id: str, max_requests: int = 1, interval: int = 15
-    ) -> None:
+    async def check_rate_limit(self, max_requests: int = 1, interval: int = 15) -> None:
         """Check if the rate limit has been exceeded.
 
         Args:
-            agent_id: The ID of the agent.
             max_requests: Maximum number of requests allowed within the rate limit window.
             interval: Time interval in minutes for the rate limit window.
 
         Raises:
             RateLimitExceeded: If the rate limit has been exceeded.
         """
-        rate_limit = await self.skill_store.get_agent_skill_data(
-            agent_id, self.name, "rate_limit"
-        )
+        rate_limit = await self.get_agent_skill_data("rate_limit")
 
         current_time = datetime.now(tz=timezone.utc)
 
@@ -65,9 +60,7 @@ class CryptoCompareBaseTool(IntentKitSkill):
                 raise RateLimitExceeded("Rate limit exceeded")
 
             rate_limit["count"] += 1
-            await self.skill_store.save_agent_skill_data(
-                agent_id, self.name, "rate_limit", rate_limit
-            )
+            await self.save_agent_skill_data("rate_limit", rate_limit)
 
             return
 
@@ -76,9 +69,7 @@ class CryptoCompareBaseTool(IntentKitSkill):
             "count": 1,
             "reset_time": (current_time + timedelta(minutes=interval)).isoformat(),
         }
-        await self.skill_store.save_agent_skill_data(
-            agent_id, self.name, "rate_limit", new_rate_limit
-        )
+        await self.save_agent_skill_data("rate_limit", new_rate_limit)
         return
 
     async def fetch_price(

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/skills/cryptocompare/fetch_news.py

@@ -56,7 +56,7 @@ class CryptoCompareFetchNews(CryptoCompareBaseTool):
             skill_config = context.agent.skill_config(self.category)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent_id, max_requests=5, interval=60)
+            await self.check_rate_limit(max_requests=5, interval=60)
 
             # Get API key from context
             api_key = skill_config.get("api_key")

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/skills/cryptocompare/fetch_price.py

@@ -66,7 +66,7 @@ class CryptoCompareFetchPrice(CryptoCompareBaseTool):
             skill_config = context.agent.skill_config(self.category)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent_id, max_requests=10, interval=60)
+            await self.check_rate_limit(max_requests=10, interval=60)
 
             # Get API key from context
             api_key = skill_config.get("api_key")

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/skills/cryptocompare/fetch_top_exchanges.py

@@ -72,7 +72,7 @@ class CryptoCompareFetchTopExchanges(CryptoCompareBaseTool):
             skill_config = context.agent.skill_config(self.category)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent_id, max_requests=5, interval=60)
+            await self.check_rate_limit(max_requests=5, interval=60)
 
             # Get API key from context
             api_key = skill_config.get("api_key")

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/skills/cryptocompare/fetch_top_market_cap.py

@@ -65,7 +65,7 @@ class CryptoCompareFetchTopMarketCap(CryptoCompareBaseTool):
             skill_config = context.agent.skill_config(self.category)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent_id, max_requests=5, interval=60)
+            await self.check_rate_limit(max_requests=5, interval=60)
 
             # Get API key from context
             api_key = skill_config.get("api_key")

{intentkit-0.8.11.dev1 → intentkit-0.8.12.dev1}/skills/cryptocompare/fetch_top_volume.py

@@ -64,7 +64,7 @@ class CryptoCompareFetchTopVolume(CryptoCompareBaseTool):
             skill_config = context.agent.skill_config(self.category)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent_id, max_requests=5, interval=60)
+            await self.check_rate_limit(max_requests=5, interval=60)
 
             # Get API key from context
             api_key = skill_config.get("api_key")