intentkit 0.8.12rc0__py3-none-any.whl → 0.8.13.dev1__py3-none-any.whl

intentkit/skills/venice_image/base.py

@@ -1,192 +1,185 @@
-import logging
-from typing import Any, Dict, Optional, Tuple
-
-from langchain_core.tools.base import ToolException
-from pydantic import Field
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import IntentKitSkill
-from intentkit.skills.venice_image.api import (
-    make_venice_api_request,
-)
-from intentkit.skills.venice_image.config import VeniceImageConfig
-
-logger = logging.getLogger(__name__)
-
-venice_base_url = "https://api.venice.ai"  # Common base URL for all Venice endpoints
-
-
-class VeniceImageBaseTool(IntentKitSkill):
-    """
-    Base class for all Venice AI image-related skills.
-
-    This class provides common functionality for interacting with the
-    Venice AI API, including:
-
-    -   Retrieving the API key (from agent or system configuration).
-    -   Applying rate limits to prevent overuse of the API.
-    -   A standardized `post` method for making API requests.
-
-    Subclasses should inherit from this class and implement their specific
-    API interactions (e.g., image generation, upscaling, inpainting)
-    by defining their own `_arun` methods and setting appropriate `name`
-    and `description` attributes.
-    """
-
-    @property
-    def category(self) -> str:
-        """
-        Returns the category of this skill, used for configuration and logging.
-        """
-        return "venice_image"
-
-    skill_store: SkillStoreABC = Field(
-        description="The skill store for persisting data and configs."
-    )
-
-    def getSkillConfig(self, context) -> VeniceImageConfig:
-        """
-        Creates a VeniceImageConfig instance from a dictionary of configuration values.
-
-        Args:
-            config: A dictionary containing configuration settings.
-
-        Returns:
-            A VeniceImageConfig object.
-        """
-
-        skill_config = context.agent.skill_config(self.category)
-        return VeniceImageConfig(
-            api_key_provider=skill_config.get("api_key_provider", "agent_owner"),
-            safe_mode=skill_config.get("safe_mode", True),
-            hide_watermark=skill_config.get("hide_watermark", True),
-            embed_exif_metadata=skill_config.get("embed_exif_metadata", False),
-            negative_prompt=skill_config.get(
-                "negative_prompt", "(worst quality: 1.4), bad quality, nsfw"
-            ),
-            rate_limit_number=skill_config.get("rate_limit_number"),
-            rate_limit_minutes=skill_config.get("rate_limit_minutes"),
-        )
-
-    def get_api_key(self) -> str:
-        """
-        Retrieves the Venice AI API key based on the api_key_provider setting.
-
-        Returns:
-            The API key if found.
-
-        Raises:
-            ToolException: If the API key is not found or provider is invalid.
-        """
-        try:
-            context = self.get_context()
-            skillConfig = self.getSkillConfig(context=context)
-            if skillConfig.api_key_provider == "agent_owner":
-                skill_config = context.agent.skill_config(self.category)
-                agent_api_key = skill_config.get("api_key")
-                if agent_api_key:
-                    logger.debug(
-                        f"Using agent-specific Venice API key for skill {self.name} in category {self.category}"
-                    )
-                    return agent_api_key
-                raise ToolException(
-                    f"No agent-owned Venice API key found for skill '{self.name}' in category '{self.category}'."
-                )
-
-            elif skillConfig.api_key_provider == "platform":
-                system_api_key = self.skill_store.get_system_config("venice_api_key")
-                if system_api_key:
-                    logger.debug(
-                        f"Using system Venice API key for skill {self.name} in category {self.category}"
-                    )
-                    return system_api_key
-                raise ToolException(
-                    f"No platform-hosted Venice API key found for skill '{self.name}' in category '{self.category}'."
-                )
-
-            else:
-                raise ToolException(
-                    f"Invalid API key provider '{skillConfig.api_key_provider}' for skill '{self.name}'"
-                )
-
-        except Exception as e:
-            raise ToolException(f"Failed to retrieve Venice API key: {str(e)}") from e
-
-    async def apply_venice_rate_limit(self, context) -> None:
-        """
-        Applies rate limiting to prevent exceeding the Venice AI API's rate limits.
-
-        Rate limits are applied based on the api_key_provider setting:
-            - 'agent_owner': uses agent-specific configuration.
-            - 'platform': uses system-wide configuration.
-        """
-        try:
-            # Get user_id from the agent context (venice_image only supports agent_owner)
-            skillConfig = self.getSkillConfig(context=context)
-
-            if skillConfig.api_key_provider == "agent_owner":
-                limit_num = skillConfig.rate_limit_number
-                limit_min = skillConfig.rate_limit_minutes
-
-                if limit_num and limit_min:
-                    # For agent_owner, use agent.id as user_id for rate limiting
-                    user_id = context.agent.id
-                    logger.debug(
-                        f"Applying Agent rate limit ({limit_num}/{limit_min} min) for user {user_id} on {self.name}"
-                    )
-                    await self.user_rate_limit_by_category(
-                        user_id, limit_num, limit_min
-                    )
-
-            elif skillConfig.api_key_provider == "platform":
-                system_limit_num = self.skill_store.get_system_config(
-                    f"{self.category}_rate_limit_number"
-                )
-                system_limit_min = self.skill_store.get_system_config(
-                    f"{self.category}_rate_limit_minutes"
-                )
-
-                if system_limit_num and system_limit_min:
-                    # For platform, use agent.id as user_id for rate limiting
-                    user_id = context.agent.id
-                    logger.debug(
-                        f"Applying System rate limit ({system_limit_num}/{system_limit_min} min) for user {user_id} on {self.name}"
-                    )
-                    await self.user_rate_limit_by_category(
-                        user_id, system_limit_num, system_limit_min
-                    )
-            # do nothing if no rate limit is
-            return None
-
-        except Exception as e:
-            raise ToolException(f"Failed to apply Venice rate limit: {str(e)}") from e
-
-    async def post(
-        self, path: str, payload: Dict[str, Any], context
-    ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-        """
-        Makes a POST request to the Venice AI API using the `make_venice_api_request`
-        function from the `skills.venice_image.api` module.
-
-        This method handles the following:
-
-        1.  Retrieving the API key using `get_api_key`.
-        2.  Constructing the request payload.
-        3.  Calling `make_venice_api_request` to make the actual API call.
-        4.  Returning the results from `make_venice_api_request`.
-
-        Args:
-            path: The API endpoint path (e.g., "/api/v1/image/generate").
-            payload: The request payload as a dictionary.
-            context: The SkillContext for accessing API keys and configs.
-
-        Returns:
-            A tuple: (success_data, error_data).
-            - If successful, success contains the JSON response from the API.
-            - If an error occurs, success is an empty dictionary, and error contains error details.
-        """
-        api_key = self.get_api_key()
-
-        return await make_venice_api_request(
-            api_key, path, payload, self.category, self.name
-        )
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+from langchain_core.tools.base import ToolException
+
+from intentkit.config.config import config
+from intentkit.skills.base import IntentKitSkill
+from intentkit.skills.venice_image.api import (
+    make_venice_api_request,
+)
+from intentkit.skills.venice_image.config import VeniceImageConfig
+
+logger = logging.getLogger(__name__)
+
+venice_base_url = "https://api.venice.ai"  # Common base URL for all Venice endpoints
+
+
+class VeniceImageBaseTool(IntentKitSkill):
+    """
+    Base class for all Venice AI image-related skills.
+
+    This class provides common functionality for interacting with the
+    Venice AI API, including:
+
+    -   Retrieving the API key (from agent or system configuration).
+    -   Applying rate limits to prevent overuse of the API.
+    -   A standardized `post` method for making API requests.
+
+    Subclasses should inherit from this class and implement their specific
+    API interactions (e.g., image generation, upscaling, inpainting)
+    by defining their own `_arun` methods and setting appropriate `name`
+    and `description` attributes.
+    """
+
+    @property
+    def category(self) -> str:
+        """
+        Returns the category of this skill, used for configuration and logging.
+        """
+        return "venice_image"
+
+    def getSkillConfig(self, context) -> VeniceImageConfig:
+        """
+        Creates a VeniceImageConfig instance from a dictionary of configuration values.
+
+        Args:
+            config: A dictionary containing configuration settings.
+
+        Returns:
+            A VeniceImageConfig object.
+        """
+
+        skill_config = context.agent.skill_config(self.category)
+        return VeniceImageConfig(
+            api_key_provider=skill_config.get("api_key_provider", "agent_owner"),
+            safe_mode=skill_config.get("safe_mode", True),
+            hide_watermark=skill_config.get("hide_watermark", True),
+            embed_exif_metadata=skill_config.get("embed_exif_metadata", False),
+            negative_prompt=skill_config.get(
+                "negative_prompt", "(worst quality: 1.4), bad quality, nsfw"
+            ),
+            rate_limit_number=skill_config.get("rate_limit_number"),
+            rate_limit_minutes=skill_config.get("rate_limit_minutes"),
+        )
+
+    def get_api_key(self) -> str:
+        """
+        Retrieves the Venice AI API key based on the api_key_provider setting.
+
+        Returns:
+            The API key if found.
+
+        Raises:
+            ToolException: If the API key is not found or provider is invalid.
+        """
+        try:
+            context = self.get_context()
+            skillConfig = self.getSkillConfig(context=context)
+            if skillConfig.api_key_provider == "agent_owner":
+                skill_config = context.agent.skill_config(self.category)
+                agent_api_key = skill_config.get("api_key")
+                if agent_api_key:
+                    logger.debug(
+                        f"Using agent-specific Venice API key for skill {self.name} in category {self.category}"
+                    )
+                    return agent_api_key
+                raise ToolException(
+                    f"No agent-owned Venice API key found for skill '{self.name}' in category '{self.category}'."
+                )
+
+            elif skillConfig.api_key_provider == "platform":
+                system_api_key = config.venice_api_key
+                if system_api_key:
+                    logger.debug(
+                        f"Using system Venice API key for skill {self.name} in category {self.category}"
+                    )
+                    return system_api_key
+                raise ToolException(
+                    f"No platform-hosted Venice API key found for skill '{self.name}' in category '{self.category}'."
+                )
+
+            else:
+                raise ToolException(
+                    f"Invalid API key provider '{skillConfig.api_key_provider}' for skill '{self.name}'"
+                )
+
+        except Exception as e:
+            raise ToolException(f"Failed to retrieve Venice API key: {str(e)}") from e
+
+    async def apply_venice_rate_limit(self, context) -> None:
+        """
+        Applies rate limiting to prevent exceeding the Venice AI API's rate limits.
+
+        Rate limits are applied based on the api_key_provider setting:
+            - 'agent_owner': uses agent-specific configuration.
+            - 'platform': uses system-wide configuration.
+        """
+        try:
+            # Get user_id from the agent context (venice_image only supports agent_owner)
+            skillConfig = self.getSkillConfig(context=context)
+
+            if skillConfig.api_key_provider == "agent_owner":
+                limit_num = skillConfig.rate_limit_number
+                limit_min = skillConfig.rate_limit_minutes
+
+                if limit_num and limit_min:
+                    # For agent_owner, use agent.id as user_id for rate limiting
+                    user_id = context.agent.id
+                    logger.debug(
+                        f"Applying Agent rate limit ({limit_num}/{limit_min} min) for user {user_id} on {self.name}"
+                    )
+                    await self.user_rate_limit_by_category(limit_num, limit_min * 60)
+
+            elif skillConfig.api_key_provider == "platform":
+                system_limit_num = getattr(
+                    config, f"{self.category}_rate_limit_number", None
+                )
+                system_limit_min = getattr(
+                    config, f"{self.category}_rate_limit_minutes", None
+                )
+
+                if system_limit_num and system_limit_min:
+                    # For platform, use agent.id as user_id for rate limiting
+                    user_id = context.agent.id
+                    logger.debug(
+                        f"Applying System rate limit ({system_limit_num}/{system_limit_min} min) for user {user_id} on {self.name}"
+                    )
+                    await self.user_rate_limit_by_category(
+                        system_limit_num, system_limit_min * 60
+                    )
+            # do nothing if no rate limit is
+            return None
+
+        except Exception as e:
+            raise ToolException(f"Failed to apply Venice rate limit: {str(e)}") from e
+
+    async def post(
+        self, path: str, payload: Dict[str, Any], context
+    ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
+        """
+        Makes a POST request to the Venice AI API using the `make_venice_api_request`
+        function from the `skills.venice_image.api` module.
+
+        This method handles the following:
+
+        1.  Retrieving the API key using `get_api_key`.
+        2.  Constructing the request payload.
+        3.  Calling `make_venice_api_request` to make the actual API call.
+        4.  Returning the results from `make_venice_api_request`.
+
+        Args:
+            path: The API endpoint path (e.g., "/api/v1/image/generate").
+            payload: The request payload as a dictionary.
+            context: The SkillContext for accessing API keys and configs.
+
+        Returns:
+            A tuple: (success_data, error_data).
+            - If successful, success contains the JSON response from the API.
+            - If an error occurs, success is an empty dictionary, and error contains error details.
+        """
+        api_key = self.get_api_key()
+
+        return await make_venice_api_request(
+            api_key, path, payload, self.category, self.name
+        )

intentkit/skills/web_scraper/__init__.py

@@ -3,7 +3,6 @@
 import logging
 from typing import TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillOwnerState, SkillState
 from intentkit.skills.web_scraper.base import WebScraperBaseTool
 from intentkit.skills.web_scraper.document_indexer import DocumentIndexer
@@ -35,7 +34,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[WebScraperBaseTool]:
     """Get all web scraper skills.
@@ -43,7 +41,6 @@ async def get_skills(
     Args:
         config: The configuration for web scraper skills.
         is_private: Whether to include private skills.
-        store: The skill store for persisting data.
 
     Returns:
         A list of web scraper skills.
@@ -60,7 +57,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_web_scraper_skill(name, store)
+        skill = get_web_scraper_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -68,40 +65,30 @@ async def get_skills(
 
 def get_web_scraper_skill(
     name: str,
-    store: SkillStoreABC,
 ) -> WebScraperBaseTool:
     """Get a web scraper skill by name.
 
     Args:
         name: The name of the skill to get
-        store: The skill store for persisting data
 
     Returns:
         The requested web scraper skill
     """
     if name == "scrape_and_index":
         if name not in _cache:
-            _cache[name] = ScrapeAndIndex(
-                skill_store=store,
-            )
+            _cache[name] = ScrapeAndIndex()
         return _cache[name]
     elif name == "query_indexed_content":
         if name not in _cache:
-            _cache[name] = QueryIndexedContent(
-                skill_store=store,
-            )
+            _cache[name] = QueryIndexedContent()
         return _cache[name]
     elif name == "website_indexer":
         if name not in _cache:
-            _cache[name] = WebsiteIndexer(
-                skill_store=store,
-            )
+            _cache[name] = WebsiteIndexer()
         return _cache[name]
     elif name == "document_indexer":
         if name not in _cache:
-            _cache[name] = DocumentIndexer(
-                skill_store=store,
-            )
+            _cache[name] = DocumentIndexer()
         return _cache[name]
     else:
         logger.warning(f"Unknown web scraper skill: {name}")

intentkit/skills/web_scraper/base.py

@@ -1,8 +1,9 @@
 from typing import Type
 
+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
 
 
@@ -12,10 +13,25 @@ class WebScraperBaseTool(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"
-    )
 
     @property
     def category(self) -> str:
         return "web_scraper"
+
+    def get_openai_api_key(self) -> str:
+        """Retrieve the OpenAI API key for embedding operations."""
+        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":
+            if not config.openai_api_key:
+                raise ToolException("OpenAI API key is not configured")
+            return config.openai_api_key
+
+        if skill_config.get("api_key"):
+            return skill_config["api_key"]
+
+        raise ToolException(
+            f"Invalid API key provider: {api_key_provider}, or no api_key in config"
+        )

intentkit/skills/web_scraper/document_indexer.py

@@ -108,17 +108,19 @@ class DocumentIndexer(WebScraperBaseTool):
             f"[{agent_id}] Document created, length: {len(document.page_content)} chars"
         )
 
+        embedding_api_key = self.get_openai_api_key()
+        vector_manager = VectorStoreManager(embedding_api_key)
+
         # Index the document
         total_chunks, was_merged = await index_documents(
-            [document], agent_id, self.skill_store, chunk_size, chunk_overlap
+            [document], agent_id, vector_manager, chunk_size, chunk_overlap
         )
 
         # Get current storage size for response
-        vs_manager = VectorStoreManager(self.skill_store)
-        current_size = await vs_manager.get_content_size(agent_id)
+        current_size = await vector_manager.get_content_size(agent_id)
 
         # Update metadata
-        metadata_manager = MetadataManager(self.skill_store)
+        metadata_manager = MetadataManager(vector_manager)
         new_metadata = metadata_manager.create_document_metadata(
             title, source, tags, [document], len(text_content)
         )

intentkit/skills/web_scraper/scrape_and_index.py

@@ -92,9 +92,12 @@ class ScrapeAndIndex(WebScraperBaseTool):
                 f"[{agent_id}] Starting scrape and index operation with {len(urls)} URLs"
             )
 
+            embedding_api_key = self.get_openai_api_key()
+            vector_manager = VectorStoreManager(embedding_api_key)
+
             # Use the utility function to scrape and index URLs
             total_chunks, was_merged, valid_urls = await scrape_and_index_urls(
-                urls, agent_id, self.skill_store, chunk_size, chunk_overlap
+                urls, agent_id, vector_manager, chunk_size, chunk_overlap
             )
 
             logger.info(
@@ -110,12 +113,11 @@ class ScrapeAndIndex(WebScraperBaseTool):
                 return "Error: No content could be extracted from the provided URLs."
 
             # Get current storage size for response
-            vs_manager = VectorStoreManager(self.skill_store)
-            current_size = await vs_manager.get_content_size(agent_id)
+            current_size = await vector_manager.get_content_size(agent_id)
             size_limit_reached = len(valid_urls) < len(urls)
 
             # Update metadata
-            metadata_manager = MetadataManager(self.skill_store)
+            metadata_manager = MetadataManager(vector_manager)
             new_metadata = metadata_manager.create_url_metadata(
                 valid_urls, [], "scrape_and_index"
             )
@@ -196,8 +198,9 @@ class QueryIndexedContent(WebScraperBaseTool):
 
             logger.info(f"[{agent_id}] Looking for vector store: {vector_store_key}")
 
-            vs_manager = VectorStoreManager(self.skill_store)
-            stored_data = await vs_manager.get_existing_vector_store(agent_id)
+            embedding_api_key = self.get_openai_api_key()
+            vector_manager = VectorStoreManager(embedding_api_key)
+            stored_data = await vector_manager.get_existing_vector_store(agent_id)
 
             if not stored_data:
                 logger.warning(f"[{agent_id}] No vector store found")
@@ -209,8 +212,8 @@ class QueryIndexedContent(WebScraperBaseTool):
 
             # Create embeddings and decode vector store
             logger.info(f"[{agent_id}] Decoding vector store")
-            embeddings = vs_manager.create_embeddings()
-            vector_store = vs_manager.decode_vector_store(
+            embeddings = vector_manager.create_embeddings()
+            vector_store = vector_manager.decode_vector_store(
                 stored_data["faiss_files"], embeddings
             )