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

intentkit/skills/dune_analytics/fetch_kol_buys.py

@@ -3,13 +3,12 @@
 Uses query ID 4832844 to retrieve a list of KOL buy transactions.
 """
 
-from typing import Any, Dict, Type
+from typing import Any
 
 import httpx
 from pydantic import BaseModel, Field
 from tenacity import retry, stop_after_attempt, wait_exponential
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.dune_analytics.base import DuneBaseTool
 
 BASE_URL = "https://api.dune.com/api/v1/query"
@@ -29,7 +28,7 @@ class KOLBuysInput(BaseModel):
 class KOLBuyData(BaseModel):
     """Data model for KOL buy results."""
 
-    data: Dict[str, Any] = Field(description="KOL buy data from Dune API")
+    data: dict[str, Any] = Field(description="KOL buy data from Dune API")
     error: str = Field(default="", description="Error message if fetch failed")
 
 
@@ -48,15 +47,14 @@ class FetchKOLBuys(DuneBaseTool):
         "Fetches a list of KOL memecoin buy transactions on Solana from Dune Analytics API using query ID 4832844. "
         "Supports a configurable limit for the number of results. Handles rate limits with retries."
     )
-    args_schema: Type[BaseModel] = KOLBuysInput
-    skill_store: SkillStoreABC = Field(description="Skill store for data persistence")
+    args_schema: type[BaseModel] = KOLBuysInput
 
     @retry(
         stop=stop_after_attempt(3), wait=wait_exponential(multiplier=5, min=5, max=60)
     )
     async def fetch_data(
         self, query_id: int, api_key: str, limit: int = 10
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch data for a specific Dune query.
 
         Args:
@@ -70,7 +68,7 @@ class FetchKOLBuys(DuneBaseTool):
         Raises:
             ToolException: If the API request fails.
         """
-        from langchain.tools.base import ToolException
+        from langchain_core.tools.base import ToolException
 
         url = f"{BASE_URL}/{query_id}/results?limit={limit}"
         headers = {"X-Dune-API-Key": api_key}

intentkit/skills/dune_analytics/fetch_nation_metrics.py

@@ -5,13 +5,12 @@ Supports predefined metrics (e.g., total_users, unique_ai_citizens) or direct qu
 
 import difflib
 import re
-from typing import Any, Dict, Type
+from typing import Any
 
 import httpx
 from pydantic import BaseModel, Field
 from tenacity import retry, stop_after_attempt, wait_exponential
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.dune_analytics.base import DuneBaseTool
 
 SUPPORTED_QUERIES = {
@@ -63,14 +62,14 @@ class MetricData(BaseModel):
     """Data model for a single metric result."""
 
     metric: str = Field(description="Metric name or query ID")
-    data: Dict[str, Any] = Field(description="Metric data from Dune API")
+    data: dict[str, Any] = Field(description="Metric data from Dune API")
     error: str = Field(default="", description="Error message if fetch failed")
 
 
 class NationMetricsOutput(BaseModel):
     """Output schema for Crestal Nation metrics."""
 
-    metrics: Dict[str, MetricData] = Field(
+    metrics: dict[str, MetricData] = Field(
         description="Dictionary of metric names or query IDs to their data"
     )
     summary: str = Field(description="Summary of fetched metrics")
@@ -85,8 +84,7 @@ class FetchNationMetrics(DuneBaseTool):
         "Supports predefined metrics, direct query IDs, or all configured metrics if none specified. "
         "Handles rate limits with retries."
     )
-    args_schema: Type[BaseModel] = NationMetricsInput
-    skill_store: SkillStoreABC = Field(description="Skill store for data persistence")
+    args_schema: type[BaseModel] = NationMetricsInput
 
     def normalize_metric(self, metric: str) -> str:
         """Normalize a metric string for matching.
@@ -124,7 +122,7 @@ class FetchNationMetrics(DuneBaseTool):
     )
     async def fetch_data(
         self, query_id: int, api_key: str, limit: int = 1000
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch data for a specific Dune query.
 
         Args:
@@ -138,7 +136,7 @@ class FetchNationMetrics(DuneBaseTool):
         Raises:
             ToolException: If the API request fails.
         """
-        from langchain.tools.base import ToolException
+        from langchain_core.tools.base import ToolException
 
         url = f"{BASE_URL}/{query_id}/results?limit={limit}"
         headers = {"X-Dune-API-Key": api_key}

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

intentkit/skills/enso/__init__.py

@@ -1,9 +1,8 @@
 """Enso skills."""
 
 import logging
-from typing import List, NotRequired, TypedDict
+from typing import NotRequired, TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.enso.base import EnsoBaseTool
 from intentkit.skills.enso.best_yield import EnsoGetBestYield
@@ -36,13 +35,12 @@ class Config(SkillConfig):
 
     states: SkillStates
     api_token: NotRequired[str]
-    main_tokens: NotRequired[List[str]]
+    main_tokens: NotRequired[list[str]]
 
 
 async def get_skills(
     config: Config,
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[EnsoBaseTool]:
     """Get all Enso skills."""
@@ -58,7 +56,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_enso_skill(name, store)
+        skill = get_enso_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -66,49 +64,31 @@ async def get_skills(
 
 def get_enso_skill(
     name: str,
-    skill_store: SkillStoreABC,
 ) -> EnsoBaseTool:
     """Get an Enso skill by name.
 
     Args:
         name: The name of the skill to get
-        skill_store: The skill store for persisting data
 
     Returns:
         The requested Enso skill
     """
     if name == "get_networks":
-        return EnsoGetNetworks(
-            skill_store=skill_store,
-        )
+        return EnsoGetNetworks()
     if name == "get_tokens":
-        return EnsoGetTokens(
-            skill_store=skill_store,
-        )
+        return EnsoGetTokens()
     if name == "get_prices":
-        return EnsoGetPrices(
-            skill_store=skill_store,
-        )
+        return EnsoGetPrices()
     if name == "get_wallet_approvals":
-        return EnsoGetWalletApprovals(
-            skill_store=skill_store,
-        )
+        return EnsoGetWalletApprovals()
     if name == "get_wallet_balances":
-        return EnsoGetWalletBalances(
-            skill_store=skill_store,
-        )
+        return EnsoGetWalletBalances()
     if name == "wallet_approve":
-        return EnsoWalletApprove(
-            skill_store=skill_store,
-        )
+        return EnsoWalletApprove()
     if name == "route_shortcut":
-        return EnsoRouteShortcut(
-            skill_store=skill_store,
-        )
+        return EnsoRouteShortcut()
     if name == "get_best_yield":
-        return EnsoGetBestYield(
-            skill_store=skill_store,
-        )
+        return EnsoGetBestYield()
     else:
         logger.warning(f"Unknown Enso skill: {name}")
         return None