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

intentkit/skills/base.py

@@ -1,23 +1,38 @@
-import asyncio
 import logging
-from typing import Any, Callable, Dict, Literal, NotRequired, Optional, TypedDict, Union
+from collections.abc import Callable, Sequence
+from typing import (
+    Any,
+    Literal,
+    NotRequired,
+    TypedDict,
+)
 
-from langchain_core.runnables import RunnableConfig
-from langchain_core.tools import BaseTool
+from coinbase_agentkit import (
+    Action,
+    AgentKit,
+    AgentKitConfig,
+    CdpEvmWalletProvider,
+)
+from langchain_core.tools import BaseTool, StructuredTool
 from langchain_core.tools.base import ToolException
 from langgraph.runtime import get_runtime
 from pydantic import (
-    BaseModel,
     ValidationError,
 )
 from pydantic.v1 import ValidationError as ValidationErrorV1
 from redis.exceptions import RedisError
 
-from intentkit.abstracts.exception import RateLimitExceeded
 from intentkit.abstracts.graph import AgentContext
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.clients import get_wallet_provider
 from intentkit.models.agent import Agent
 from intentkit.models.redis import get_redis
+from intentkit.models.skill import (
+    AgentSkillData,
+    AgentSkillDataCreate,
+    ChatSkillData,
+    ChatSkillDataCreate,
+)
+from intentkit.utils.error import IntentKitAPIError, RateLimitExceeded
 
 SkillState = Literal["disabled", "public", "private"]
 SkillOwnerState = Literal["disabled", "private"]
@@ -28,39 +43,9 @@ class SkillConfig(TypedDict):
     """Abstract base class for skill configuration."""
 
     enabled: bool
-    states: Dict[str, SkillState | SkillOwnerState]
+    states: dict[str, SkillState | SkillOwnerState]
     api_key_provider: NotRequired[APIKeyProviderValue]
-    __extra__: NotRequired[Dict[str, Any]]
-
-
-class SkillContext(BaseModel):
-    skill_category: str
-    agent_id: str
-    user_id: Optional[str] = None
-    chat_id: Optional[str] = None
-    app_id: Optional[str] = None
-    entrypoint: Literal["web", "twitter", "telegram", "trigger", "api"]
-    is_private: bool
-    payer: Optional[str] = None
-    _agent: Optional[Agent] = None
-
-    @property
-    def agent(self) -> Agent:
-        if self._agent is None:
-            self._agent = asyncio.run(Agent.get(self.agent_id))
-        return self._agent
-
-    @property
-    def config(self) -> Dict[str, Any]:
-        agent = self.agent
-        config = None
-        if agent.skills:
-            config = agent.skills.get(self.skill_category)
-        if not config:
-            raise ValueError(
-                f"Skill {self.skill_category} not found in agent {self.agent_id}"
-            )
-        return config
+    __extra__: NotRequired[dict[str, Any]]
 
 
 class IntentKitSkill(BaseTool):
@@ -68,17 +53,16 @@ class IntentKitSkill(BaseTool):
     Will have predefined abilities.
     """
 
-    skill_store: SkillStoreABC
     # overwrite the value of BaseTool
-    handle_tool_error: Optional[Union[bool, str, Callable[[ToolException], str]]] = (
+    handle_tool_error: bool | str | Callable[[ToolException], str] | None = (
         lambda e: f"tool error: {e}"
     )
     """Handle the content of the ToolException thrown."""
 
     # overwrite the value of BaseTool
-    handle_validation_error: Optional[
-        Union[bool, str, Callable[[Union[ValidationError, ValidationErrorV1]], str]]
-    ] = lambda e: f"validation error: {e}"
+    handle_validation_error: (
+        bool | str | Callable[[ValidationError | ValidationErrorV1], str] | None
+    ) = lambda e: f"validation error: {e}"
     """Handle the content of the ValidationError thrown."""
 
     # Logger for the class
@@ -89,15 +73,12 @@ class IntentKitSkill(BaseTool):
         """Get the category of the skill."""
         raise NotImplementedError
 
-    async def user_rate_limit(
-        self, user_id: str, limit: int, minutes: int, key: str
-    ) -> None:
+    async def user_rate_limit(self, limit: int, seconds: int, key: str) -> None:
         """Check if a user has exceeded the rate limit for this skill.
 
         Args:
-            user_id: The ID of the user to check
             limit: Maximum number of requests allowed
-            minutes: Time window in minutes
+            seconds: Time window in seconds
             key: The key to use for rate limiting (e.g., skill name or category)
 
         Raises:
@@ -106,25 +87,48 @@ class IntentKitSkill(BaseTool):
         Returns:
             None: Always returns None if no exception is raised
         """
-        if not user_id:
-            return None  # No rate limiting for users without ID
+        try:
+            context = self.get_context()
+        except ValueError:
+            self.logger.info(
+                "AgentContext not available, skipping rate limit for %s",
+                key,
+            )
+            return None
+
+        user_identifier = context.user_id or context.agent_id
+        if not user_identifier:
+            return None  # No rate limiting when no identifier is available
+
+        try:
+            max_requests = int(limit)
+            window_seconds = int(seconds)
+        except (TypeError, ValueError):
+            self.logger.info(
+                "Invalid user rate limit parameters for %s: limit=%r, seconds=%r",
+                key,
+                limit,
+                seconds,
+            )
+            return None
+
+        if window_seconds <= 0 or max_requests <= 0:
+            return None
 
         try:
             redis = get_redis()
             # Create a unique key for this rate limit and user
-            rate_limit_key = f"rate_limit:{key}:{user_id}"
+            rate_limit_key = f"rate_limit:{key}:{user_identifier}"
 
             # Get the current count
             count = await redis.incr(rate_limit_key)
 
             # Set expiration if this is the first request
             if count == 1:
-                await redis.expire(
-                    rate_limit_key, minutes * 60
-                )  # Convert minutes to seconds
+                await redis.expire(rate_limit_key, window_seconds)
 
             # Check if user has exceeded the limit
-            if count > limit:
+            if count > max_requests:
                 raise RateLimitExceeded(f"Rate limit exceeded for {key}")
 
             return None
@@ -140,62 +144,221 @@ class IntentKitSkill(BaseTool):
             )
             return None
 
-    async def user_rate_limit_by_skill(
-        self, user_id: str, limit: int, minutes: int
-    ) -> None:
+    async def user_rate_limit_by_skill(self, limit: int, seconds: int) -> None:
         """Check if a user has exceeded the rate limit for this specific skill.
 
         This uses the skill name as the rate limit key.
 
         Args:
-            user_id: The ID of the user to check
             limit: Maximum number of requests allowed
-            minutes: Time window in minutes
+            seconds: Time window in seconds
 
         Raises:
             RateLimitExceeded: If the user has exceeded the rate limit
         """
-        return await self.user_rate_limit(user_id, limit, minutes, self.name)
+        return await self.user_rate_limit(limit, seconds, self.name)
 
-    async def user_rate_limit_by_category(
-        self, user_id: str, limit: int, minutes: int
-    ) -> None:
+    async def user_rate_limit_by_category(self, limit: int, seconds: int) -> None:
         """Check if a user has exceeded the rate limit for this skill category.
 
         This uses the skill category as the rate limit key, which means the limit
         is shared across all skills in the same category.
 
         Args:
-            user_id: The ID of the user to check
             limit: Maximum number of requests allowed
-            minutes: Time window in minutes
+            seconds: Time window in seconds
 
         Raises:
             RateLimitExceeded: If the user has exceeded the rate limit
         """
-        return await self.user_rate_limit(user_id, limit, minutes, self.category)
+        return await self.user_rate_limit(limit, seconds, self.category)
+
+    async def global_rate_limit(self, limit: int, seconds: int, key: str) -> None:
+        """Check if a global rate limit has been exceeded for a given key.
+
+        Args:
+            limit: Maximum number of requests allowed
+            seconds: Time window in seconds
+            key: The key to use for rate limiting (e.g., skill name or category)
+
+        Raises:
+            RateLimitExceeded: If the global limit has been exceeded
+
+        Returns:
+            None: Always returns None if no exception is raised
+        """
+        try:
+            max_requests = int(limit)
+            window_seconds = int(seconds)
+        except (TypeError, ValueError):
+            self.logger.info(
+                "Invalid global rate limit parameters for %s: limit=%r, seconds=%r",
+                key,
+                limit,
+                seconds,
+            )
+            return None
+
+        if window_seconds <= 0 or max_requests <= 0:
+            return None
+
+        try:
+            redis = get_redis()
+            rate_limit_key = f"rate_limit:{key}"
+
+            count = await redis.incr(rate_limit_key)
+
+            if count == 1:
+                await redis.expire(rate_limit_key, window_seconds)
+
+            if count > max_requests:
+                raise RateLimitExceeded(f"Global rate limit exceeded for {key}")
+
+            return None
+
+        except RuntimeError:
+            self.logger.info(
+                "Redis not initialized, skipping global rate limit for %s",
+                key,
+            )
+            return None
+        except RedisError as e:
+            self.logger.info(
+                f"Redis error in global rate limiting: {e}, skipping rate limit for {key}"
+            )
+            return None
+
+    async def global_rate_limit_by_skill(self, limit: int, seconds: int) -> None:
+        """Apply a global rate limit scoped to this specific skill."""
+        return await self.global_rate_limit(limit, seconds, self.name)
+
+    async def global_rate_limit_by_category(self, limit: int, seconds: int) -> None:
+        """Apply a global rate limit scoped to this skill category."""
+        return await self.global_rate_limit(limit, seconds, self.category)
 
     def _run(self, *args: Any, **kwargs: Any) -> Any:
         raise NotImplementedError(
             "Use _arun instead, IntentKit only supports synchronous skill calls"
         )
 
-    def context_from_config(self, runner_config: RunnableConfig) -> SkillContext:
-        if "configurable" not in runner_config:
-            raise ValueError("configurable not in runner_config")
-        configurable = runner_config["configurable"]
-        if not configurable:
-            raise ValueError("configurable in runnable config is empty")
-        return SkillContext(
-            skill_category=self.category,
-            agent_id=configurable.get("agent_id"),
-            user_id=configurable.get("user_id"),
-            app_id=configurable.get("app_id"),
-            chat_id=configurable.get("chat_id"),
-            entrypoint=configurable.get("entrypoint"),
-            is_private=configurable.get("is_private"),
-        )
-
-    def get_context(self) -> AgentContext:
+    @staticmethod
+    def get_context() -> AgentContext:
         runtime = get_runtime(AgentContext)
+        if runtime.context is None or not isinstance(runtime.context, AgentContext):
+            raise ValueError("No AgentContext found")
         return runtime.context
+
+    async def get_agent_skill_data(
+        self,
+        key: str,
+    ) -> dict[str, Any] | None:
+        """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,
+    ) -> dict[str, Any] | None:
+        """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,
+    ) -> dict[str, Any] | None:
+        """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,
+    provider_factories: Sequence[Callable[[], object]],
+    *,
+    agent: Agent | None = None,
+) -> list[Action]:
+    """Build an AgentKit instance and return its actions."""
+
+    if agent is None:
+        try:
+            context = IntentKitSkill.get_context()
+        except ValueError as exc:  # pragma: no cover - defensive guard
+            raise IntentKitAPIError(
+                500,
+                "AgentContextMissing",
+                "Agent context is required to initialize AgentKit actions.",
+            ) from exc
+        agent = context.agent
+
+    if agent.id != agent_id:
+        raise IntentKitAPIError(
+            400,
+            "AgentMismatch",
+            "The requested agent does not match the active context agent.",
+        )
+
+    wallet_provider: CdpEvmWalletProvider = await get_wallet_provider(agent)
+
+    agent_kit = AgentKit(
+        AgentKitConfig(
+            wallet_provider=wallet_provider,
+            action_providers=[factory() for factory in provider_factories],
+        )
+    )
+    return agent_kit.get_actions()
+
+
+def action_to_structured_tool(action: Action) -> StructuredTool:
+    """Convert an AgentKit action to a LangChain StructuredTool."""
+
+    def _tool_fn(**kwargs: object) -> str:
+        return action.invoke(kwargs)
+
+    tool = StructuredTool(
+        name=action.name,
+        description=action.description,
+        func=_tool_fn,
+        args_schema=action.args_schema,
+    )
+    tool.handle_tool_error = lambda e: f"tool error: {e}"
+    tool.handle_validation_error = lambda e: f"validation error: {e}"
+    return tool

intentkit/skills/basename/__init__.py

@@ -0,0 +1,51 @@
+"""Basename AgentKit skills."""
+
+from typing import TypedDict
+
+from coinbase_agentkit import basename_action_provider
+
+from intentkit.models.agent import Agent
+from intentkit.skills.base import (
+    SkillConfig,
+    SkillState,
+    action_to_structured_tool,
+    get_agentkit_actions,
+)
+from intentkit.skills.basename.base import BasenameBaseTool
+
+
+class SkillStates(TypedDict):
+    BasenameActionProvider_register_basename: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for Basename skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    agent_id: str,
+    agent: Agent | None = None,
+    **_,
+) -> list[BasenameBaseTool]:
+    """Get all Basename skills."""
+
+    available_skills: list[str] = []
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        if state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    actions = await get_agentkit_actions(
+        agent_id, [basename_action_provider], agent=agent
+    )
+    tools: list[BasenameBaseTool] = []
+    for skill in available_skills:
+        for action in actions:
+            if action.name.endswith(skill):
+                tools.append(action_to_structured_tool(action))
+    return tools

intentkit/skills/basename/base.py

@@ -0,0 +1,11 @@
+"""Basename AgentKit skills base class."""
+
+from intentkit.skills.cdp.base import CDPBaseTool
+
+
+class BasenameBaseTool(CDPBaseTool):
+    """Base class for Basename tools."""
+
+    @property
+    def category(self) -> str:
+        return "basename"

intentkit/skills/basename/basename.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128">
+  <defs>
+    <linearGradient id="bg" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#4c7dff" />
+      <stop offset="100%" stop-color="#0b2f80" />
+    </linearGradient>
+  </defs>
+  <rect width="128" height="128" fill="url(#bg)" rx="16" />
+  <text x="50%" y="52%" font-family="Arial,Helvetica,sans-serif" font-size="60" fill="#ffffff" font-weight="700" text-anchor="middle">B</text>
+  <text x="50%" y="86%" font-family="Arial,Helvetica,sans-serif" font-size="20" fill="#dbe4ff" text-anchor="middle">Base</text>
+</svg>

intentkit/skills/basename/schema.json

@@ -0,0 +1,58 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Basename",
+  "description": "Basename ENS-style name registration via Coinbase AgentKit",
+  "x-icon": "https://ai.service.crestal.dev/skills/basename/basename.svg",
+  "x-tags": [
+    "Crypto",
+    "Identity"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "BasenameActionProvider_register_basename": {
+          "type": "string",
+          "title": "Register Basename",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "State for BasenameActionProvider_register_basename",
+          "default": "disabled"
+        }
+      },
+      "description": "States for each Basename skill (disabled, public, or private)"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Who provides the API key",
+      "enum": [
+        "platform"
+      ],
+      "x-enum-title": [
+        "Nation Hosted"
+      ],
+      "default": "platform"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "additionalProperties": true
+}