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

intentkit/skills/dune_analytics/schema.json

@@ -1,99 +1,104 @@
-{
-  "title": "Dune Analytics",
-  "description": "Dune Analytics skills to fetch data from Dune Analytics API.",
-  "x-icon": "https://ai.service.crestal.dev/skills/dune_analytics/dune.png",
-  "type": "object",
-  "properties": {
-    "enabled": {
-      "type": "boolean",
-      "title": "Enabled",
-      "description": "Whether this skill is enabled",
-      "default": false
-    },
-    "states": {
-      "title": "Skill States",
-      "type": "object",
-      "properties": {
-        "fetch_nation_metrics": {
-          "type": "string",
-          "title": "Fetch Crestal Nation Metrics",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "Fetches Crestal Nation metrics (e.g., total_users, agents/citizens, market_cap) from Dune Analytics API.",
-          "default": "disabled"
-        },
-        "fetch_kol_buys": {
-          "type": "string",
-          "title": "Fetch KOL Memecoin Buys",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "Fetches a list of KOL memecoin buy transactions on Solana from Dune Analytics API.",
-          "default": "disabled"
-        }
-      }
-    },
-    "api_key_provider": {
-      "type": "string",
-      "title": "API Key Provider",
-      "description": "Provider of the API key for Dune service",
-      "enum": [
-        "agent_owner"
-      ],
-      "x-enum-title": [
-        "Owner Provided"
-      ],
-      "default": "agent_owner"
-    }
-  },
-  "required": [
-    "states",
-    "enabled"
-  ],
-  "if": {
-    "properties": {
-      "api_key_provider": {
-        "const": "agent_owner"
-      }
-    }
-  },
-  "then": {
-    "properties": {
-      "api_key": {
-        "type": "string",
-        "title": "Dune API Key",
-        "description": "API key for Dune Analytics (X-Dune-API-Key).",
-        "x-link": "[Get your API key](https://docs.dune.com/api-reference/overview/authentication)",
-        "x-sensitive": true
-      }
-    },
-    "if": {
-      "properties": {
-        "enabled": {
-          "const": true
-        }
-      }
-    },
-    "then": {
-      "required": [
-        "api_key"
-      ]
-    }
-  },
-  "additionalProperties": true
-}
+{
+  "title": "Dune Analytics",
+  "description": "Dune Analytics skills to fetch data from Dune Analytics API.",
+  "x-icon": "https://ai.service.crestal.dev/skills/dune_analytics/dune.png",
+  "type": "object",
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "title": "Skill States",
+      "type": "object",
+      "properties": {
+        "fetch_nation_metrics": {
+          "type": "string",
+          "title": "Fetch Crestal Nation Metrics",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Fetches Crestal Nation metrics (e.g., total_users, agents/citizens, market_cap) from Dune Analytics API.",
+          "default": "disabled"
+        },
+        "fetch_kol_buys": {
+          "type": "string",
+          "title": "Fetch KOL Memecoin Buys",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Fetches a list of KOL memecoin buy transactions on Solana from Dune Analytics API.",
+          "default": "disabled"
+        }
+      }
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Provider of the API key for Dune service",
+      "enum": [
+        "agent_owner"
+      ],
+      "x-enum-title": [
+        "Owner Provided"
+      ],
+      "default": "agent_owner"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "if": {
+    "properties": {
+      "api_key_provider": {
+        "const": "agent_owner"
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "api_key": {
+        "type": "string",
+        "title": "Dune API Key",
+        "description": "API key for Dune Analytics (X-Dune-API-Key).",
+        "x-link": "[Get your API key](https://docs.dune.com/api-reference/overview/authentication)",
+        "x-sensitive": true
+      }
+    },
+    "if": {
+      "properties": {
+        "enabled": {
+          "const": true
+        }
+      }
+    },
+    "then": {
+      "required": [
+        "api_key"
+      ]
+    }
+  },
+  "additionalProperties": true,
+  "x-tags": [
+    "Analytics",
+    "Crypto",
+    "Knowledge Base"
+  ]
+}

intentkit/skills/elfa/__init__.py

@@ -3,7 +3,6 @@
 import logging
 from typing import NotRequired, TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.elfa.base import ElfaBaseTool
 from intentkit.skills.elfa.mention import (
@@ -36,7 +35,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[ElfaBaseTool]:
     """Get all Elfa skills.
@@ -44,7 +42,6 @@ async def get_skills(
     Args:
         config: The configuration for Elfa skills.
         is_private: Whether to include private skills.
-        store: The skill store for persisting data.
 
     Returns:
         A list of Elfa skills.
@@ -61,7 +58,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_elfa_skill(name, store)
+        skill = get_elfa_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -69,13 +66,11 @@ async def get_skills(
 
 def get_elfa_skill(
     name: str,
-    store: SkillStoreABC,
 ) -> ElfaBaseTool:
     """Get an Elfa skill by name.
 
     Args:
         name: The name of the skill to get
-        store: The skill store for persisting data
 
     Returns:
         The requested Elfa skill
@@ -83,30 +78,22 @@ def get_elfa_skill(
 
     if name == "get_top_mentions":
         if name not in _cache:
-            _cache[name] = ElfaGetTopMentions(
-                skill_store=store,
-            )
+            _cache[name] = ElfaGetTopMentions()
         return _cache[name]
 
     elif name == "search_mentions":
         if name not in _cache:
-            _cache[name] = ElfaSearchMentions(
-                skill_store=store,
-            )
+            _cache[name] = ElfaSearchMentions()
         return _cache[name]
 
     elif name == "get_trending_tokens":
         if name not in _cache:
-            _cache[name] = ElfaGetTrendingTokens(
-                skill_store=store,
-            )
+            _cache[name] = ElfaGetTrendingTokens()
         return _cache[name]
 
     elif name == "get_smart_stats":
         if name not in _cache:
-            _cache[name] = ElfaGetSmartStats(
-                skill_store=store,
-            )
+            _cache[name] = ElfaGetSmartStats()
         return _cache[name]
 
     else:

intentkit/skills/elfa/base.py

@@ -1,9 +1,7 @@
-from typing import Type
-
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.config.config import config
 from intentkit.skills.base import IntentKitSkill
 
 base_url = "https://api.elfa.ai/v2"
@@ -14,24 +12,22 @@ class ElfaBaseTool(IntentKitSkill):
 
     name: str = Field(description="The name of the tool")
     description: str = Field(description="A description of what the tool does")
-    args_schema: Type[BaseModel]
-    skill_store: SkillStoreABC = Field(
-        description="The skill store for persisting data"
-    )
+    args_schema: type[BaseModel]
 
     def get_api_key(self) -> str:
         context = self.get_context()
         skill_config = context.agent.skill_config(self.category)
         api_key_provider = skill_config.get("api_key_provider")
         if api_key_provider == "platform":
-            return self.skill_store.get_system_config("elfa_api_key")
+            if not config.elfa_api_key:
+                raise ToolException("Elfa API key is not configured")
+            return config.elfa_api_key
         # for backward compatibility, may only have api_key in skill_config
-        elif skill_config.get("api_key"):
+        if skill_config.get("api_key"):
             return skill_config.get("api_key")
-        else:
-            raise ToolException(
-                f"Invalid API key provider: {api_key_provider}, or no api_key in config"
-            )
+        raise ToolException(
+            f"Invalid API key provider: {api_key_provider}, or no api_key in config"
+        )
 
     @property
     def category(self) -> str:

intentkit/skills/elfa/mention.py

@@ -1,6 +1,6 @@
 """Mention-related skills for Elfa AI API."""
 
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -12,19 +12,19 @@ class ElfaGetTopMentionsInput(BaseModel):
     """Input parameters for top mentions."""
 
     ticker: str = Field(description="Stock ticker symbol (e.g., ETH, $ETH, BTC, $BTC)")
-    timeWindow: Optional[str] = Field(
+    timeWindow: str | None = Field(
         "1h", description="Time window (e.g., '1h', '24h', '7d')"
     )
-    page: Optional[int] = Field(1, description="Page number for pagination")
-    pageSize: Optional[int] = Field(10, description="Number of items per page")
+    page: int | None = Field(1, description="Page number for pagination")
+    pageSize: int | None = Field(10, description="Number of items per page")
 
 
 class ElfaGetTopMentionsOutput(BaseModel):
     """Output structure for top mentions response."""
 
     success: bool
-    data: Optional[List[MentionData]] = Field(None, description="List of top mentions")
-    metadata: Optional[Dict[str, Any]] = Field(None, description="Response metadata")
+    data: list[MentionData] | None = Field(None, description="List of top mentions")
+    metadata: dict[str, Any] | None = Field(None, description="Response metadata")
 
 
 class ElfaGetTopMentions(ElfaBaseTool):
@@ -46,7 +46,7 @@ class ElfaGetTopMentions(ElfaBaseTool):
     Updated hourly. Returns engagement metrics and account information for market sentiment analysis.
     
     Use this to track public opinion, identify trending news, and monitor investor discussions."""
-    args_schema: Type[BaseModel] = ElfaGetTopMentionsInput
+    args_schema: type[BaseModel] = ElfaGetTopMentionsInput
 
     async def _arun(
         self,
@@ -102,30 +102,28 @@ class ElfaGetTopMentions(ElfaBaseTool):
 class ElfaSearchMentionsInput(BaseModel):
     """Input parameters for search mentions."""
 
-    keywords: Optional[str] = Field(
+    keywords: str | None = Field(
         None,
         description="Up to 5 keywords to search for, separated by commas. Phrases accepted",
     )
-    accountName: Optional[str] = Field(
+    accountName: str | None = Field(
         None,
         description="Account username to filter by (optional if keywords provided)",
     )
-    timeWindow: Optional[str] = Field("7d", description="Time window for search")
-    limit: Optional[int] = Field(20, description="Number of results to return (max 30)")
-    searchType: Optional[str] = Field(
-        "or", description="Type of search ('and' or 'or')"
-    )
-    cursor: Optional[str] = Field(None, description="Cursor for pagination")
+    timeWindow: str | None = Field("7d", description="Time window for search")
+    limit: int | None = Field(20, description="Number of results to return (max 30)")
+    searchType: str | None = Field("or", description="Type of search ('and' or 'or')")
+    cursor: str | None = Field(None, description="Cursor for pagination")
 
 
 class ElfaSearchMentionsOutput(BaseModel):
     """Output structure for search mentions response."""
 
     success: bool
-    data: Optional[List[MentionData]] = Field(
+    data: list[MentionData] | None = Field(
         None, description="List of matching mentions"
     )
-    metadata: Optional[Dict[str, Any]] = Field(
+    metadata: dict[str, Any] | None = Field(
         None, description="Response metadata with cursor"
     )
 
@@ -150,16 +148,16 @@ class ElfaSearchMentions(ElfaBaseTool):
     Updated every 5 minutes. Access 30 days of recent data or historical archives.
     
     Use this for market research, brand monitoring, opinion tracking, and competitive analysis."""
-    args_schema: Type[BaseModel] = ElfaSearchMentionsInput
+    args_schema: type[BaseModel] = ElfaSearchMentionsInput
 
     async def _arun(
         self,
-        keywords: Optional[str] = None,
-        accountName: Optional[str] = None,
+        keywords: str | None = None,
+        accountName: str | None = None,
         timeWindow: str = "7d",
         limit: int = 20,
         searchType: str = "or",
-        cursor: Optional[str] = None,
+        cursor: str | None = None,
         **kwargs,
     ) -> ElfaSearchMentionsOutput:
         """

intentkit/skills/elfa/schema.json

@@ -5,7 +5,8 @@
   "description": "Integration with Elfa AI API providing data analysis and processing capabilities with secure authentication for advanced data operations",
   "x-icon": "https://ai.service.crestal.dev/skills/elfa/elfa.jpg",
   "x-tags": [
-    "Data"
+    "AI",
+    "Analytics"
   ],
   "x-nft-requirement": 1,
   "properties": {
@@ -13,7 +14,7 @@
       "type": "boolean",
       "title": "Enabled",
       "description": "Whether this skill is enabled",
-      "default": true
+      "default": false
     },
     "states": {
       "type": "object",

intentkit/skills/elfa/stats.py

@@ -1,6 +1,6 @@
 """Smart stats skill for Elfa AI API."""
 
-from typing import Any, Dict, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -18,8 +18,8 @@ class ElfaGetSmartStatsOutput(BaseModel):
     """Output structure for smart stats response."""
 
     success: bool
-    data: Optional[SmartStatsData] = Field(None, description="Smart stats data")
-    metadata: Optional[Dict[str, Any]] = Field(None, description="Response metadata")
+    data: SmartStatsData | None = Field(None, description="Smart stats data")
+    metadata: dict[str, Any] | None = Field(None, description="Response metadata")
 
 
 class ElfaGetSmartStats(ElfaBaseTool):
@@ -43,7 +43,7 @@ class ElfaGetSmartStats(ElfaBaseTool):
     description: str = """Get comprehensive social media metrics for a username including smart following count, 
     engagement scores, and follower analytics. Use this for competitor analysis, influencer identification, 
     and social media performance audits."""
-    args_schema: Type[BaseModel] = ElfaGetSmartStatsInput
+    args_schema: type[BaseModel] = ElfaGetSmartStatsInput
 
     async def _arun(self, username: str, **kwargs) -> ElfaGetSmartStatsOutput:
         """

intentkit/skills/elfa/tokens.py

@@ -1,6 +1,6 @@
 """Trending tokens skill for Elfa AI API."""
 
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -11,13 +11,13 @@ from .utils import make_elfa_request
 class ElfaGetTrendingTokensInput(BaseModel):
     """Input parameters for trending tokens."""
 
-    timeWindow: Optional[str] = Field(
+    timeWindow: str | None = Field(
         "7d",
         description="Time window for trending analysis (e.g., '30m', '1h', '4h', '24h', '7d', '30d')",
     )
-    page: Optional[int] = Field(1, description="Page number for pagination")
-    pageSize: Optional[int] = Field(50, description="Number of items per page")
-    minMentions: Optional[int] = Field(
+    page: int | None = Field(1, description="Page number for pagination")
+    pageSize: int | None = Field(50, description="Number of items per page")
+    minMentions: int | None = Field(
         5, description="Minimum number of mentions required"
     )
 
@@ -25,20 +25,20 @@ class ElfaGetTrendingTokensInput(BaseModel):
 class TrendingToken(BaseModel):
     """Individual trending token data."""
 
-    token: Optional[str] = Field(None, description="Token symbol")
-    current_count: Optional[int] = Field(None, description="Current mention count")
-    previous_count: Optional[int] = Field(None, description="Previous mention count")
-    change_percent: Optional[float] = Field(None, description="Change percentage")
+    token: str | None = Field(None, description="Token symbol")
+    current_count: int | None = Field(None, description="Current mention count")
+    previous_count: int | None = Field(None, description="Previous mention count")
+    change_percent: float | None = Field(None, description="Change percentage")
 
 
 class ElfaGetTrendingTokensOutput(BaseModel):
     """Output structure for trending tokens response."""
 
     success: bool
-    data: Optional[List[TrendingToken]] = Field(
+    data: list[TrendingToken] | None = Field(
         None, description="List of trending tokens"
     )
-    metadata: Optional[Dict[str, Any]] = Field(None, description="Response metadata")
+    metadata: dict[str, Any] | None = Field(None, description="Response metadata")
 
 
 class ElfaGetTrendingTokens(ElfaBaseTool):
@@ -60,7 +60,7 @@ class ElfaGetTrendingTokens(ElfaBaseTool):
     Updated every 5 minutes. Smart mentions provide sophisticated discussion volume measurement beyond simple keyword counts.
     
     Use this to identify tokens gaining traction, gauge market sentiment, and research potential investments."""
-    args_schema: Type[BaseModel] = ElfaGetTrendingTokensInput
+    args_schema: type[BaseModel] = ElfaGetTrendingTokensInput
 
     async def _arun(
         self,

intentkit/skills/elfa/utils.py

@@ -1,9 +1,9 @@
 """Utility functions for Elfa skills."""
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 import httpx
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
 from .base import base_url
@@ -14,13 +14,13 @@ class ElfaResponse(BaseModel):
 
     success: bool
     data: Any = None
-    metadata: Optional[Dict[str, Any]] = None
+    metadata: dict[str, Any] | None = None
 
 
 async def make_elfa_request(
     endpoint: str,
     api_key: str,
-    params: Optional[Dict[str, Any]] = None,
+    params: dict[str, Any] | None = None,
     timeout: int = 30,
 ) -> ElfaResponse:
     """
@@ -82,32 +82,32 @@ async def make_elfa_request(
 class RepostBreakdown(BaseModel):
     """Repost breakdown data."""
 
-    smart: Optional[int] = None
-    ct: Optional[int] = None
+    smart: int | None = None
+    ct: int | None = None
 
 
 class Account(BaseModel):
     """Account information."""
 
-    username: Optional[str] = None
-    isVerified: Optional[bool] = None
+    username: str | None = None
+    isVerified: bool | None = None
 
 
 class MentionData(BaseModel):
     """Base mention data structure used across multiple endpoints."""
 
-    tweetId: Optional[str] = Field(None, description="Tweet ID")
-    link: Optional[str] = Field(None, description="Link to the tweet")
-    likeCount: Optional[int] = Field(None, description="Number of likes")
-    repostCount: Optional[int] = Field(None, description="Number of reposts")
-    viewCount: Optional[int] = Field(None, description="Number of views")
-    quoteCount: Optional[int] = Field(None, description="Number of quotes")
-    replyCount: Optional[int] = Field(None, description="Number of replies")
-    bookmarkCount: Optional[int] = Field(None, description="Number of bookmarks")
-    mentionedAt: Optional[str] = Field(None, description="When mentioned")
-    type: Optional[str] = Field(None, description="Post type")
-    account: Optional[Account] = Field(None, description="Account information")
-    repostBreakdown: Optional[RepostBreakdown] = Field(
+    tweetId: str | None = Field(None, description="Tweet ID")
+    link: str | None = Field(None, description="Link to the tweet")
+    likeCount: int | None = Field(None, description="Number of likes")
+    repostCount: int | None = Field(None, description="Number of reposts")
+    viewCount: int | None = Field(None, description="Number of views")
+    quoteCount: int | None = Field(None, description="Number of quotes")
+    replyCount: int | None = Field(None, description="Number of replies")
+    bookmarkCount: int | None = Field(None, description="Number of bookmarks")
+    mentionedAt: str | None = Field(None, description="When mentioned")
+    type: str | None = Field(None, description="Post type")
+    account: Account | None = Field(None, description="Account information")
+    repostBreakdown: RepostBreakdown | None = Field(
         None, description="Repost breakdown"
     )
 
@@ -115,15 +115,13 @@ class MentionData(BaseModel):
 class SmartStatsData(BaseModel):
     """Smart stats data structure."""
 
-    smartFollowingCount: Optional[int] = Field(
-        None, description="Smart following count"
-    )
-    averageEngagement: Optional[float] = Field(None, description="Average engagement")
-    averageReach: Optional[float] = Field(None, description="Average reach")
-    smartFollowerCount: Optional[int] = Field(None, description="Smart follower count")
-    followerCount: Optional[int] = Field(None, description="Total follower count")
+    smartFollowingCount: int | None = Field(None, description="Smart following count")
+    averageEngagement: float | None = Field(None, description="Average engagement")
+    averageReach: float | None = Field(None, description="Average reach")
+    smartFollowerCount: int | None = Field(None, description="Smart follower count")
+    followerCount: int | None = Field(None, description="Total follower count")
 
 
-def clean_params(params: Dict[str, Any]) -> Dict[str, Any]:
+def clean_params(params: dict[str, Any]) -> dict[str, Any]:
     """Remove None values from parameters dict."""
     return {k: v for k, v in params.items() if v is not None}