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

intentkit/skills/twitter/like_tweet.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Type
 
 from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
@@ -32,7 +31,7 @@ class TwitterLikeTweet(TwitterBaseTool):
 
     name: str = NAME
     description: str = PROMPT
-    args_schema: Type[BaseModel] = TwitterLikeTweetInput
+    args_schema: type[BaseModel] = TwitterLikeTweetInput
 
     async def _arun(self, tweet_id: str, **kwargs):
         context = self.get_context()
@@ -40,16 +39,13 @@ class TwitterLikeTweet(TwitterBaseTool):
             skill_config = context.agent.skill_config(self.category)
             twitter = get_twitter_client(
                 agent_id=context.agent_id,
-                skill_store=self.skill_store,
                 config=skill_config,
             )
             client = await twitter.get_client()
 
             # Check rate limit only when not using OAuth
             if not twitter.use_key:
-                await self.check_rate_limit(
-                    context.agent_id, max_requests=100, interval=1440
-                )
+                await self.check_rate_limit(max_requests=100, interval=1440)
 
             # Like the tweet using tweepy client
             response = await client.like(tweet_id=tweet_id, user_auth=twitter.use_key)

intentkit/skills/twitter/post_tweet.py

@@ -1,10 +1,10 @@
 import logging
-from typing import Optional, Type
 
 from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.clients import get_twitter_client
+from intentkit.config.config import config
 from intentkit.skills.twitter.base import TwitterBaseTool
 
 NAME = "twitter_post_tweet"
@@ -23,7 +23,7 @@ class TwitterPostTweetInput(BaseModel):
         description="Tweet text (280 chars for regular users, 25,000 bytes for verified)",
         max_length=25000,
     )
-    image: Optional[str] = Field(
+    image: str | None = Field(
         default=None, description="Optional URL of an image to attach to the tweet"
     )
 
@@ -41,12 +41,12 @@ class TwitterPostTweet(TwitterBaseTool):
 
     name: str = NAME
     description: str = PROMPT
-    args_schema: Type[BaseModel] = TwitterPostTweetInput
+    args_schema: type[BaseModel] = TwitterPostTweetInput
 
     async def _arun(
         self,
         text: str,
-        image: Optional[str] = None,
+        image: str | None = None,
         **kwargs,
     ):
         context = self.get_context()
@@ -54,16 +54,13 @@ class TwitterPostTweet(TwitterBaseTool):
             skill_config = context.agent.skill_config(self.category)
             twitter = get_twitter_client(
                 agent_id=context.agent_id,
-                skill_store=self.skill_store,
                 config=skill_config,
             )
             client = await twitter.get_client()
 
             # Check rate limit only when not using OAuth
             if not twitter.use_key:
-                await self.check_rate_limit(
-                    context.agent_id, max_requests=24, interval=1440
-                )
+                await self.check_rate_limit(max_requests=24, interval=1440)
 
             media_ids = []
             image_warning = ""
@@ -71,7 +68,7 @@ class TwitterPostTweet(TwitterBaseTool):
             # Handle image upload if provided
             if image:
                 # Validate image URL - must be from system's S3 CDN
-                aws_s3_cdn_url = self.skill_store.get_system_config("aws_s3_cdn_url")
+                aws_s3_cdn_url = config.aws_s3_cdn_url
                 if aws_s3_cdn_url and image.startswith(aws_s3_cdn_url):
                     # Use the TwitterClient method to upload the image
                     media_ids = await twitter.upload_media(context.agent_id, image)

intentkit/skills/twitter/reply_tweet.py

@@ -1,10 +1,10 @@
 import logging
-from typing import Optional, Type
 
 from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.clients import get_twitter_client
+from intentkit.config.config import config
 from intentkit.skills.twitter.base import TwitterBaseTool
 
 NAME = "twitter_reply_tweet"
@@ -24,7 +24,7 @@ class TwitterReplyTweetInput(BaseModel):
         description="Tweet text (280 chars for regular users, 25,000 bytes for verified)",
         max_length=25000,
     )
-    image: Optional[str] = Field(
+    image: str | None = Field(
         default=None, description="Optional URL of an image to attach to the reply"
     )
 
@@ -42,13 +42,13 @@ class TwitterReplyTweet(TwitterBaseTool):
 
     name: str = NAME
     description: str = PROMPT
-    args_schema: Type[BaseModel] = TwitterReplyTweetInput
+    args_schema: type[BaseModel] = TwitterReplyTweetInput
 
     async def _arun(
         self,
         tweet_id: str,
         text: str,
-        image: Optional[str] = None,
+        image: str | None = None,
         **kwargs,
     ):
         context = self.get_context()
@@ -56,16 +56,13 @@ class TwitterReplyTweet(TwitterBaseTool):
             skill_config = context.agent.skill_config(self.category)
             twitter = get_twitter_client(
                 agent_id=context.agent_id,
-                skill_store=self.skill_store,
                 config=skill_config,
             )
             client = await twitter.get_client()
 
             # Check rate limit only when not using OAuth
             if not twitter.use_key:
-                await self.check_rate_limit(
-                    context.agent_id, max_requests=48, interval=1440
-                )
+                await self.check_rate_limit(max_requests=48, interval=1440)
 
             media_ids = []
             image_warning = ""
@@ -73,7 +70,7 @@ class TwitterReplyTweet(TwitterBaseTool):
             # Handle image upload if provided
             if image:
                 # Validate image URL - must be from system's S3 CDN
-                aws_s3_cdn_url = self.skill_store.get_system_config("aws_s3_cdn_url")
+                aws_s3_cdn_url = config.aws_s3_cdn_url
                 if aws_s3_cdn_url and image.startswith(aws_s3_cdn_url):
                     # Use the TwitterClient method to upload the image
                     media_ids = await twitter.upload_media(context.agent_id, image)

intentkit/skills/twitter/retweet.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Type
 
 from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
@@ -32,7 +31,7 @@ class TwitterRetweet(TwitterBaseTool):
 
     name: str = NAME
     description: str = PROMPT
-    args_schema: Type[BaseModel] = TwitterRetweetInput
+    args_schema: type[BaseModel] = TwitterRetweetInput
 
     async def _arun(self, tweet_id: str, **kwargs):
         context = self.get_context()
@@ -40,16 +39,13 @@ class TwitterRetweet(TwitterBaseTool):
             skill_config = context.agent.skill_config(self.category)
             twitter = get_twitter_client(
                 agent_id=context.agent_id,
-                skill_store=self.skill_store,
                 config=skill_config,
             )
             client = await twitter.get_client()
 
             # Check rate limit only when not using OAuth
             if not twitter.use_key:
-                await self.check_rate_limit(
-                    context.agent_id, max_requests=5, interval=15
-                )
+                await self.check_rate_limit(max_requests=5, interval=15)
 
             # Get authenticated user's ID
             user_id = twitter.self_id

intentkit/skills/twitter/search_tweets.py

@@ -1,6 +1,5 @@
 import datetime
 import logging
-from typing import Type
 
 from pydantic import BaseModel, Field
 
@@ -33,7 +32,7 @@ class TwitterSearchTweets(TwitterBaseTool):
 
     name: str = NAME
     description: str = PROMPT
-    args_schema: Type[BaseModel] = TwitterSearchTweetsInput
+    args_schema: type[BaseModel] = TwitterSearchTweetsInput
 
     async def _arun(self, query: str, **kwargs):
         context = self.get_context()
@@ -42,21 +41,16 @@ class TwitterSearchTweets(TwitterBaseTool):
             skill_config = context.agent.skill_config(self.category)
             twitter = get_twitter_client(
                 agent_id=context.agent_id,
-                skill_store=self.skill_store,
                 config=skill_config,
             )
             client = await twitter.get_client()
 
             # Check rate limit only when not using OAuth
             if not twitter.use_key:
-                await self.check_rate_limit(
-                    context.agent_id, max_requests=1, interval=15
-                )
+                await self.check_rate_limit(max_requests=1, interval=15)
 
             # Get since_id from store to avoid duplicate results
-            last = await self.skill_store.get_agent_skill_data(
-                context.agent_id, self.name, query
-            )
+            last = await self.get_agent_skill_data(query)
             last = last or {}
             since_id = last.get("since_id")
 
@@ -104,9 +98,7 @@ class TwitterSearchTweets(TwitterBaseTool):
             if tweets.get("meta") and tweets.get("meta").get("newest_id"):
                 last["since_id"] = tweets["meta"]["newest_id"]
                 last["timestamp"] = datetime.datetime.now().isoformat()
-                await self.skill_store.save_agent_skill_data(
-                    context.agent_id, self.name, query, last
-                )
+                await self.save_agent_skill_data(query, last)
 
             return tweets
 

intentkit/skills/unrealspeech/__init__.py

@@ -1,6 +1,5 @@
 from typing import TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.unrealspeech.base import UnrealSpeechBaseTool
 from intentkit.skills.unrealspeech.text_to_speech import TextToSpeech
@@ -23,7 +22,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[UnrealSpeechBaseTool]:
     """Get all UnrealSpeech tools."""
@@ -37,19 +35,16 @@ async def get_skills(
             available_skills.append(skill_name)
 
     # Get each skill using the cached getter
-    return [get_unrealspeech_skill(name, store) for name in available_skills]
+    return [get_unrealspeech_skill(name) for name in available_skills]
 
 
 def get_unrealspeech_skill(
     name: str,
-    store: SkillStoreABC,
 ) -> UnrealSpeechBaseTool:
     """Get an UnrealSpeech skill by name."""
     if name == "text_to_speech":
         if name not in _cache:
-            _cache[name] = TextToSpeech(
-                skill_store=store,
-            )
+            _cache[name] = TextToSpeech()
         return _cache[name]
     else:
         raise ValueError(f"Unknown UnrealSpeech skill: {name}")

intentkit/skills/unrealspeech/base.py

@@ -1,9 +1,6 @@
-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.skills.base import IntentKitSkill
 
 
@@ -12,10 +9,7 @@ class UnrealSpeechBaseTool(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()

intentkit/skills/unrealspeech/text_to_speech.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from typing import Any, Dict, Literal, Optional, Type
+from typing import Any, Literal
 
 import httpx
 from langchain_core.callbacks.manager import CallbackManagerForToolRun
@@ -31,7 +31,7 @@ class TextToSpeechInput(BaseModel):
         default=0.0,
     )
 
-    timestamp_type: Optional[Literal["word", "sentence"]] = Field(
+    timestamp_type: Literal["word", "sentence"] | None = Field(
         description="The type of timestamps to include in the response. 'word' for word-level timestamps, 'sentence' for sentence-level, or None for no timestamps.",
         default="word",
     )
@@ -52,9 +52,9 @@ class TextToSpeech(UnrealSpeechBaseTool):
         "Returns URLs to the generated audio file and word-level timestamps.\n"
         "Provides various voice options and speech customization parameters."
     )
-    args_schema: Type[BaseModel] = TextToSpeechInput
+    args_schema: type[BaseModel] = TextToSpeechInput
 
-    def get_env_var(self, env_var_name: str) -> Optional[str]:
+    def get_env_var(self, env_var_name: str) -> str | None:
         """Helper method to get environment variables."""
         return os.environ.get(env_var_name)
 
@@ -64,11 +64,11 @@ class TextToSpeech(UnrealSpeechBaseTool):
         voice_id: str = "af_sarah",
         bitrate: str = "192k",
         speed: float = 0.0,
-        timestamp_type: Optional[Literal["word", "sentence"]] = "word",
-        config: Optional[Any] = None,
-        run_manager: Optional[CallbackManagerForToolRun] = None,
+        timestamp_type: Literal["word", "sentence"] | None = "word",
+        config: Any | None = None,
+        run_manager: CallbackManagerForToolRun | None = None,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Run the tool to convert text to speech."""
 
         # Get the API key from context config if available

intentkit/skills/venice_audio/__init__.py

@@ -1,106 +1,98 @@
-import logging
-from typing import List, Literal, Optional, TypedDict
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import SkillConfig, SkillState
-from intentkit.skills.venice_audio.base import VeniceAudioBaseTool
-from intentkit.skills.venice_audio.venice_audio import VeniceAudioTool
-
-logger = logging.getLogger(__name__)
-
-
-_cache: dict[str, VeniceAudioBaseTool] = {}
-
-_SKILL_NAME_TO_CLASS_MAP = {
-    "text_to_speech": VeniceAudioTool,
-    # Add new mappings here: "skill_name": SkillClassName
-}
-
-
-class SkillStates(TypedDict):
-    text_to_speech: SkillState
-
-
-class Config(SkillConfig):
-    enabled: bool
-    voice_model: Literal["af_heart", "bm_lewis", "custom"]
-    states: SkillStates  # type: ignore
-    api_key_provider: Optional[Literal["agent_owner"]]
-
-    # conditionally required
-    api_key: Optional[str]
-    voice_model_custom: Optional[list[str]]
-
-    # optional
-    rate_limit_number: Optional[int]
-    rate_limit_minutes: Optional[int]
-
-
-async def get_skills(
-    config: "Config",
-    is_private: bool,
-    store: SkillStoreABC,
-    **_,  # Allow for extra arguments if the loader passes them
-) -> list[VeniceAudioBaseTool]:
-    """
-    Factory function to create and return Venice Audio skill tools.
-
-    Args:
-        config: The configuration dictionary for the Venice Audio skill.
-        skill_store: The skill store instance.
-        agent_id: The ID of the agent requesting the skills.
-
-    Returns:
-        A list of VeniceAudioBaseTool instances for the Venice Audio skill.
-    """
-    # Check if the entire category is disabled first
-    if not config.get("enabled", False):
-        return []
-
-    available_skills: List[VeniceAudioBaseTool] = []
-    skill_states = config.get("states", {})
-
-    # Iterate through all known skills defined in the map
-    for skill_name in _SKILL_NAME_TO_CLASS_MAP:
-        state = skill_states.get(
-            skill_name, "disabled"
-        )  # Default to disabled if not in config
-
-        if state == "disabled":
-            continue
-        elif state == "public" or (state == "private" and is_private):
-            # If enabled, get the skill instance using the factory function
-            skill_instance = get_venice_audio_skill(skill_name, store)
-            if skill_instance:
-                available_skills.append(skill_instance)
-            else:
-                # This case should ideally not happen if the map is correct
-                logger.warning(f"Could not instantiate known skill: {skill_name}")
-
-    return available_skills
-
-
-def get_venice_audio_skill(
-    name: str,
-    store: SkillStoreABC,
-) -> Optional[VeniceAudioBaseTool]:
-    """
-    Factory function to get a cached Venice Audio skill instance by name.
-
-    Args:
-        name: The name of voice model.
-        store: The skill store, passed to the skill constructor.
-
-    Returns:
-        The requested Venice Audio skill instance, or None if the name is unknown.
-    """
-
-    # Return from cache immediately if already exists
-    if name in _cache:
-        return _cache[name]
-
-    # Cache and return the newly created instance
-    _cache[name] = VeniceAudioTool(
-        skill_store=store,
-    )
-    return _cache[name]
+import logging
+from typing import Literal, TypedDict
+
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.venice_audio.base import VeniceAudioBaseTool
+from intentkit.skills.venice_audio.venice_audio import VeniceAudioTool
+
+logger = logging.getLogger(__name__)
+
+_cache: dict[str, VeniceAudioBaseTool] = {}
+
+_SKILL_NAME_TO_CLASS_MAP = {
+    "text_to_speech": VeniceAudioTool,
+    # Add new mappings here: "skill_name": SkillClassName
+}
+
+
+class SkillStates(TypedDict):
+    text_to_speech: SkillState
+
+
+class Config(SkillConfig):
+    enabled: bool
+    voice_model: Literal["af_heart", "bm_lewis", "custom"]
+    states: SkillStates  # type: ignore
+    api_key_provider: Literal["agent_owner"] | None
+
+    # conditionally required
+    api_key: str | None
+    voice_model_custom: list[str] | None
+
+    # optional
+    rate_limit_number: int | None
+    rate_limit_minutes: int | None
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    **_,  # Allow for extra arguments if the loader passes them
+) -> list[VeniceAudioBaseTool]:
+    """
+    Factory function to create and return Venice Audio skill tools.
+
+    Args:
+        config: The configuration dictionary for the Venice Audio skill.
+        agent_id: The ID of the agent requesting the skills.
+
+    Returns:
+        A list of VeniceAudioBaseTool instances for the Venice Audio skill.
+    """
+    # Check if the entire category is disabled first
+    if not config.get("enabled", False):
+        return []
+
+    available_skills: list[VeniceAudioBaseTool] = []
+    skill_states = config.get("states", {})
+
+    # Iterate through all known skills defined in the map
+    for skill_name in _SKILL_NAME_TO_CLASS_MAP:
+        state = skill_states.get(
+            skill_name, "disabled"
+        )  # Default to disabled if not in config
+
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            # If enabled, get the skill instance using the factory function
+            skill_instance = get_venice_audio_skill(skill_name)
+            if skill_instance:
+                available_skills.append(skill_instance)
+            else:
+                # This case should ideally not happen if the map is correct
+                logger.warning(f"Could not instantiate known skill: {skill_name}")
+
+    return available_skills
+
+
+def get_venice_audio_skill(
+    name: str,
+) -> VeniceAudioBaseTool | None:
+    """
+    Factory function to get a cached Venice Audio skill instance by name.
+
+    Args:
+        name: The name of voice model.
+
+    Returns:
+        The requested Venice Audio skill instance, or None if the name is unknown.
+    """
+
+    # Return from cache immediately if already exists
+    if name in _cache:
+        return _cache[name]
+
+    # Cache and return the newly created instance
+    _cache[name] = VeniceAudioTool()
+    return _cache[name]