intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__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.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
+
+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], dict[str, Any] | None]:
+        """
+        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/venice_image/config.py

@@ -1,35 +1,33 @@
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class VeniceImageConfig(BaseModel):
-    """Skill Config for Venice Image."""
-
-    api_key_provider: str = Field(
-        default="agent_owner",
-        description="Provider of the API Key, could be agent_owner or platform",
-    )
-    safe_mode: bool = Field(
-        default=True,
-        description="Whether to use safe mode. If enabled, this will blur images that are classified as having adult content",
-    )
-    hide_watermark: bool = Field(
-        default=True,
-        description="Whether to hide the Venice watermark. Venice may ignore this parameter for certain generated content.",
-    )
-    embed_exif_metadata: bool = Field(
-        default=False, description="Whether to embed EXIF metadata in the image."
-    )
-    negative_prompt: str = Field(
-        default="(worst quality: 1.4), bad quality, nsfw",
-        description="The default negative prompt used when no other prompt is provided.",
-    )
-    rate_limit_number: Optional[int] = Field(
-        default=None,
-        description="Maximum number of allowed calls within the specified time window.",
-    )
-    rate_limit_minutes: Optional[int] = Field(
-        default=None,
-        description="Duration of the time window (in minutes) for rate limiting.",
-    )
+from pydantic import BaseModel, Field
+
+
+class VeniceImageConfig(BaseModel):
+    """Skill Config for Venice Image."""
+
+    api_key_provider: str = Field(
+        default="agent_owner",
+        description="Provider of the API Key, could be agent_owner or platform",
+    )
+    safe_mode: bool = Field(
+        default=True,
+        description="Whether to use safe mode. If enabled, this will blur images that are classified as having adult content",
+    )
+    hide_watermark: bool = Field(
+        default=True,
+        description="Whether to hide the Venice watermark. Venice may ignore this parameter for certain generated content.",
+    )
+    embed_exif_metadata: bool = Field(
+        default=False, description="Whether to embed EXIF metadata in the image."
+    )
+    negative_prompt: str = Field(
+        default="(worst quality: 1.4), bad quality, nsfw",
+        description="The default negative prompt used when no other prompt is provided.",
+    )
+    rate_limit_number: int | None = Field(
+        default=None,
+        description="Maximum number of allowed calls within the specified time window.",
+    )
+    rate_limit_minutes: int | None = Field(
+        default=None,
+        description="Duration of the time window (in minutes) for rate limiting.",
+    )

intentkit/skills/venice_image/image_enhance/image_enhance.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 from pydantic import HttpUrl
 
@@ -30,8 +29,8 @@ class ImageEnhance(VeniceImageEnhanceBaseTool):
         self,
         image_url: HttpUrl,
         enhancePrompt: str,
-        replication: Optional[float] = 0.35,
-        enhanceCreativity: Optional[float] = 0.5,
+        replication: float | None = 0.35,
+        enhanceCreativity: float | None = 0.5,
         **kwargs,
     ) -> dict:
         """

intentkit/skills/venice_image/image_enhance/image_enhance_base.py

@@ -1,23 +1,21 @@
-from typing import Type
-
-from pydantic import BaseModel, Field
-
-# Import the generic base and shared input
-from intentkit.skills.venice_image.base import VeniceImageBaseTool
-from intentkit.skills.venice_image.image_enhance.image_enhance_input import (
-    VeniceImageEnhanceInput,
-)
-
-
-class VeniceImageEnhanceBaseTool(VeniceImageBaseTool):
-    """
-    Base class for Venice AI *Image Enchanching* tools.
-    Inherits from VeniceAIBaseTool and handles specifics of the
-    /image/upscale endpoint
-    """
-
-    args_schema: Type[BaseModel] = VeniceImageEnhanceInput
-    name: str = Field(description="The unique name of the image Enchanching tool.")
-    description: str = Field(
-        description="A description of what the image Enchanching tool does."
-    )
+from pydantic import BaseModel, Field
+
+# Import the generic base and shared input
+from intentkit.skills.venice_image.base import VeniceImageBaseTool
+from intentkit.skills.venice_image.image_enhance.image_enhance_input import (
+    VeniceImageEnhanceInput,
+)
+
+
+class VeniceImageEnhanceBaseTool(VeniceImageBaseTool):
+    """
+    Base class for Venice AI *Image Enchanching* tools.
+    Inherits from VeniceAIBaseTool and handles specifics of the
+    /image/upscale endpoint
+    """
+
+    args_schema: type[BaseModel] = VeniceImageEnhanceInput
+    name: str = Field(description="The unique name of the image Enchanching tool.")
+    description: str = Field(
+        description="A description of what the image Enchanching tool does."
+    )

intentkit/skills/venice_image/image_enhance/image_enhance_input.py

@@ -1,40 +1,38 @@
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class VeniceImageEnhanceInput(BaseModel):
-    """Input for Venice Image Enhance tool (scale=1, enhance=True)."""
-
-    image_url: str = Field(
-        description="The URL of the image to enhance. Must be a publicly accessible URL."
-    )
-
-    enhancePrompt: str = Field(
-        ...,
-        max_length=1500,
-        description=(
-            "Required prompt describing the desired enhancement style. "
-            "Best used with short descriptors like 'gold', 'marble', or 'angry, menacing'."
-        ),
-    )
-
-    replication: Optional[float] = Field(
-        default=0.35,
-        ge=0.1,
-        le=1.0,
-        description=(
-            "How strongly lines and noise in the base image are preserved. "
-            "Higher values retain more noise and detail but are less smooth."
-        ),
-    )
-
-    enhanceCreativity: float = Field(
-        default=0.5,
-        ge=0.0,
-        le=1.0,
-        description=(
-            "How much the enhancement AI is allowed to change the image. "
-            "0 = minimal change, 1 = generate a new image entirely."
-        ),
-    )
+from pydantic import BaseModel, Field
+
+
+class VeniceImageEnhanceInput(BaseModel):
+    """Input for Venice Image Enhance tool (scale=1, enhance=True)."""
+
+    image_url: str = Field(
+        description="The URL of the image to enhance. Must be a publicly accessible URL."
+    )
+
+    enhancePrompt: str = Field(
+        ...,
+        max_length=1500,
+        description=(
+            "Required prompt describing the desired enhancement style. "
+            "Best used with short descriptors like 'gold', 'marble', or 'angry, menacing'."
+        ),
+    )
+
+    replication: float | None = Field(
+        default=0.35,
+        ge=0.1,
+        le=1.0,
+        description=(
+            "How strongly lines and noise in the base image are preserved. "
+            "Higher values retain more noise and detail but are less smooth."
+        ),
+    )
+
+    enhanceCreativity: float = Field(
+        default=0.5,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "How much the enhancement AI is allowed to change the image. "
+            "0 = minimal change, 1 = generate a new image entirely."
+        ),
+    )

intentkit/skills/venice_image/image_generation/image_generation_base.py

@@ -1,7 +1,7 @@
 import base64
 import hashlib
 import logging
-from typing import Any, Dict, Literal, Optional, Type
+from typing import Any, Literal
 
 from pydantic import BaseModel, Field
 
@@ -24,7 +24,7 @@ class VeniceImageGenerationBaseTool(VeniceImageBaseTool):
     """
 
     # --- Attributes specific to Image Generation ---
-    args_schema: Type[BaseModel] = VeniceImageGenerationInput
+    args_schema: type[BaseModel] = VeniceImageGenerationInput
 
     # --- Attributes Subclasses MUST Define ---
     name: str = Field(description="The unique name of the image generation tool/model.")
@@ -38,15 +38,15 @@ class VeniceImageGenerationBaseTool(VeniceImageBaseTool):
     async def _arun(
         self,
         prompt: str,
-        seed: Optional[int] = None,
-        negative_prompt: Optional[str] = None,
-        width: Optional[int] = 1024,
-        height: Optional[int] = 1024,
+        seed: int | None = None,
+        negative_prompt: str | None = None,
+        width: int | None = 1024,
+        height: int | None = 1024,
         format: Literal["png", "jpeg", "webp"] = "png",
-        cfg_scale: Optional[float] = 7.5,
-        style_preset: Optional[str] = "Photographic",
+        cfg_scale: float | None = 7.5,
+        style_preset: str | None = "Photographic",
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         try:
             context = self.get_context()
             skillConfig = self.getSkillConfig(context)