intentkit 0.7.5.dev3__py3-none-any.whl → 0.8.34.dev7__py3-none-any.whl

intentkit/skills/venice_audio/venice_audio.py

@@ -1,15 +1,14 @@
 import hashlib
 import json
 import logging
-from typing import Any, Dict, Optional, Type
+from typing import Any
 
 import httpx
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.clients.s3 import store_file
 from intentkit.skills.venice_audio.base import VeniceAudioBaseTool
 from intentkit.skills.venice_audio.input import AllowedAudioFormat, VeniceAudioInput
-from intentkit.utils.s3 import FileType, store_file_bytes
 
 logger = logging.getLogger(__name__)
 
@@ -33,22 +32,19 @@ class VeniceAudioTool(VeniceAudioBaseTool):
         "Requires input text. Optional parameters include speed (0.25-4.0, default 1.0) "
         "and audio format (mp3, opus, aac, flac, wav, pcm, default mp3)."
     )
-    args_schema: Type[BaseModel] = VeniceAudioInput
-    skill_store: SkillStoreABC = Field(
-        description="The skill store instance for accessing system/agent configurations and persisting data."
-    )
+    args_schema: type[BaseModel] = VeniceAudioInput
 
     async def _arun(
         self,
-        input: str,
+        voice_input: str,
         voice_model: str,
-        speed: Optional[float] = 1.0,
-        response_format: Optional[AllowedAudioFormat] = "mp3",
+        speed: float | None = 1.0,
+        response_format: AllowedAudioFormat | None = "mp3",
         **kwargs,  # type: ignore
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """
         Generates audio using the configured voice model via Venice AI TTS /audio/speech endpoint.
-        Stores the resulting audio using store_file_bytes.
+        Stores the resulting audio using the generic S3 helper.
         Returns a dictionary containing audio details on success, or API error details on failure.
         """
         context = self.get_context()
@@ -96,9 +92,9 @@ class VeniceAudioTool(VeniceAudioBaseTool):
             await self.apply_rate_limit(context)
 
             # --- Prepare API Call ---
-            payload: Dict[str, Any] = {
+            payload: dict[str, Any] = {
                 "model": tts_model_id,
-                "input": input,
+                "input": voice_input,
                 "voice": voice_model,
                 "response_format": final_response_format,
                 "speed": speed if speed is not None else 1.0,
@@ -155,11 +151,32 @@ class VeniceAudioTool(VeniceAudioBaseTool):
                     key = f"{self.category}/{voice_model}/{audio_hash}.{file_extension}"
 
                     size_limit = 1024 * 20  # 20Mb Size limit
-                    stored_url = await store_file_bytes(
-                        file_bytes=audio_bytes,
+                    audio_size = len(audio_bytes)
+                    if audio_size > size_limit:
+                        message = f"Generated audio exceeds the allowed size of {size_limit} bytes."
+                        logger.error(
+                            "Failed to store audio (Voice: %s): %s",
+                            voice_model,
+                            message,
+                        )
+                        return {
+                            "error": True,
+                            "error_type": "FileSizeLimitExceeded",
+                            "message": message,
+                            "voice_model": voice_model,
+                            "requested_format": final_response_format,
+                        }
+
+                    mime_type = (
+                        content_type_header.split(";", 1)[0].strip()
+                        if content_type_header
+                        else None
+                    )
+                    stored_url = await store_file(
+                        content=audio_bytes,
                         key=key,
-                        file_type=FileType.AUDIO,
-                        size_limit_bytes=size_limit,
+                        content_type=mime_type,
+                        size=audio_size,
                     )
 
                     if not stored_url:
@@ -182,12 +199,12 @@ class VeniceAudioTool(VeniceAudioBaseTool):
                     return {
                         "audio_url": stored_url,
                         "audio_bytes_sha256": audio_hash,
-                        "content_type": content_type_header,
+                        "content_type": mime_type or content_type_header,
                         "voice_model": voice_model,
                         "tts_engine": tts_model_id,
                         "speed": speed if speed is not None else 1.0,
                         "response_format": final_response_format,
-                        "input_text_length": len(input),
+                        "input_text_length": len(voice_input),
                         "error": False,
                         "status_code": response.status_code,
                     }

intentkit/skills/venice_image/__init__.py

@@ -1,154 +1,147 @@
-import logging
-from typing import NotRequired, Optional, TypedDict
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import (
-    SkillConfig,
-    SkillState,
-)
-
-# Import the base tool and all specific model skill classes
-from intentkit.skills.venice_image.base import VeniceImageBaseTool
-from intentkit.skills.venice_image.image_enhance.image_enhance import ImageEnhance
-from intentkit.skills.venice_image.image_generation.image_generation_fluently_xl import (
-    ImageGenerationFluentlyXL,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_flux_dev import (
-    ImageGenerationFluxDev,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_flux_dev_uncensored import (
-    ImageGenerationFluxDevUncensored,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_lustify_sdxl import (
-    ImageGenerationLustifySDXL,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_pony_realism import (
-    ImageGenerationPonyRealism,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_stable_diffusion_3_5 import (
-    ImageGenerationStableDiffusion35,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_venice_sd35 import (
-    ImageGenerationVeniceSD35,
-)
-from intentkit.skills.venice_image.image_upscale.image_upscale import ImageUpscale
-from intentkit.skills.venice_image.image_vision.image_vision import ImageVision
-
-# Cache skills at the system level, because they are stateless and only depend on the store
-_cache: dict[str, VeniceImageBaseTool] = {}
-
-logger = logging.getLogger(__name__)
-
-
-# Define the expected structure for the 'states' dictionary in the config
-class SkillStates(TypedDict):
-    image_upscale: SkillState
-    image_enhance: SkillState
-    image_vision: SkillState
-    image_generation_flux_dev: SkillState
-    image_generation_flux_dev_uncensored: SkillState
-    image_generation_venice_sd35: SkillState
-    image_generation_fluently_xl: SkillState
-    image_generation_lustify_sdxl: SkillState
-    image_generation_pony_realism: SkillState
-    image_generation_stable_diffusion_3_5: SkillState
-    # Add new skill names here if more models are added
-
-
-# Define the overall configuration structure for the venice_image category
-class Config(SkillConfig):
-    """Configuration for Venice Image skills."""
-
-    enabled: bool  # Keep standard enabled flag
-    states: SkillStates
-    api_key_provider: str = "agent_owner"
-    api_key: NotRequired[Optional[str]]  # Explicitly Optional
-    safe_mode: NotRequired[bool]  # Defaults handled in base or usage
-    hide_watermark: NotRequired[bool]  # Defaults handled in base or usage
-    negative_prompt: NotRequired[str]  # Defaults handled in base or usage
-    rate_limit_number: NotRequired[Optional[int]]  # Explicitly Optional
-    rate_limit_minutes: NotRequired[Optional[int]]  # Explicitly Optional
-
-
-_SKILL_NAME_TO_CLASS_MAP: dict[str, type[VeniceImageBaseTool]] = {
-    "image_upscale": ImageUpscale,
-    "image_enhance": ImageEnhance,
-    "image_vision": ImageVision,
-    "image_generation_flux_dev": ImageGenerationFluxDev,
-    "image_generation_flux_dev_uncensored": ImageGenerationFluxDevUncensored,
-    "image_generation_venice_sd35": ImageGenerationVeniceSD35,
-    "image_generation_fluently_xl": ImageGenerationFluentlyXL,
-    "image_generation_lustify_sdxl": ImageGenerationLustifySDXL,
-    "image_generation_pony_realism": ImageGenerationPonyRealism,
-    "image_generation_stable_diffusion_3_5": ImageGenerationStableDiffusion35,
-}
-
-
-async def get_skills(
-    config: "Config",
-    is_private: bool,
-    store: SkillStoreABC,
-    **_,  # Allow for extra arguments if the loader passes them
-) -> list[VeniceImageBaseTool]:
-    """Get all enabled Venice Image skills based on configuration and privacy level.
-
-    Args:
-        config: The configuration for Venice Image skills.
-        is_private: Whether the context is private (e.g., agent owner).
-        store: The skill store for persisting data and accessing system config.
-
-    Returns:
-        A list of instantiated and enabled Venice Image skill objects.
-    """
-    # Check if the entire category is disabled first
-    if not config.get("enabled", False):
-        return []
-
-    available_skills: list[VeniceImageBaseTool] = []
-
-    # Include skills based on their state
-    for skill_name, state in config["states"].items():
-        if state == "disabled":
-            continue
-        elif state == "public" or (state == "private" and is_private):
-            available_skills.append(skill_name)
-
-    # Get each skill using the cached getter
-    result = []
-    for name in available_skills:
-        skill = get_venice_image_skill(name, store, config)
-        if skill:
-            result.append(skill)
-    return result
-
-
-def get_venice_image_skill(
-    name: str,
-    store: SkillStoreABC,
-    config: "Config",
-) -> Optional[VeniceImageBaseTool]:
-    """
-    Factory function to get a cached Venice Image skill instance by name.
-
-    Args:
-        name: The name of the skill to get (must match keys in _SKILL_NAME_TO_CLASS_MAP).
-        store: The skill store, passed to the skill constructor.
-
-    Returns:
-        The requested Venice Image skill instance, or None if the name is unknown.
-    """
-
-    # Return from cache immediately if already exists
-    if name in _cache:
-        return _cache[name]
-
-    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
-    if not skill_class:
-        logger.warning(f"Unknown Venice skill: {name}")
-        return None
-
-    # Cache and return the newly created instance
-    _cache[name] = skill_class(
-        skill_store=store,
-    )
-    return _cache[name]
+import logging
+from typing import NotRequired, TypedDict
+
+from intentkit.skills.base import (
+    SkillConfig,
+    SkillState,
+)
+
+# Import the base tool and all specific model skill classes
+from intentkit.skills.venice_image.base import VeniceImageBaseTool
+from intentkit.skills.venice_image.image_enhance.image_enhance import ImageEnhance
+from intentkit.skills.venice_image.image_generation.image_generation_fluently_xl import (
+    ImageGenerationFluentlyXL,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_flux_dev import (
+    ImageGenerationFluxDev,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_flux_dev_uncensored import (
+    ImageGenerationFluxDevUncensored,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_lustify_sdxl import (
+    ImageGenerationLustifySDXL,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_pony_realism import (
+    ImageGenerationPonyRealism,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_stable_diffusion_3_5 import (
+    ImageGenerationStableDiffusion35,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_venice_sd35 import (
+    ImageGenerationVeniceSD35,
+)
+from intentkit.skills.venice_image.image_upscale.image_upscale import ImageUpscale
+from intentkit.skills.venice_image.image_vision.image_vision import ImageVision
+
+# Cache skills at the system level, because they are stateless and only depend on the store
+_cache: dict[str, VeniceImageBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+# Define the expected structure for the 'states' dictionary in the config
+class SkillStates(TypedDict):
+    image_upscale: SkillState
+    image_enhance: SkillState
+    image_vision: SkillState
+    image_generation_flux_dev: SkillState
+    image_generation_flux_dev_uncensored: SkillState
+    image_generation_venice_sd35: SkillState
+    image_generation_fluently_xl: SkillState
+    image_generation_lustify_sdxl: SkillState
+    image_generation_pony_realism: SkillState
+    image_generation_stable_diffusion_3_5: SkillState
+    # Add new skill names here if more models are added
+
+
+# Define the overall configuration structure for the venice_image category
+class Config(SkillConfig):
+    """Configuration for Venice Image skills."""
+
+    enabled: bool  # Keep standard enabled flag
+    states: SkillStates
+    api_key_provider: str = "agent_owner"
+    api_key: NotRequired[str | None]  # Explicitly Optional
+    safe_mode: NotRequired[bool]  # Defaults handled in base or usage
+    hide_watermark: NotRequired[bool]  # Defaults handled in base or usage
+    negative_prompt: NotRequired[str]  # Defaults handled in base or usage
+    rate_limit_number: NotRequired[int | None]  # Explicitly Optional
+    rate_limit_minutes: NotRequired[int | None]  # Explicitly Optional
+
+
+_SKILL_NAME_TO_CLASS_MAP: dict[str, type[VeniceImageBaseTool]] = {
+    "image_upscale": ImageUpscale,
+    "image_enhance": ImageEnhance,
+    "image_vision": ImageVision,
+    "image_generation_flux_dev": ImageGenerationFluxDev,
+    "image_generation_flux_dev_uncensored": ImageGenerationFluxDevUncensored,
+    "image_generation_venice_sd35": ImageGenerationVeniceSD35,
+    "image_generation_fluently_xl": ImageGenerationFluentlyXL,
+    "image_generation_lustify_sdxl": ImageGenerationLustifySDXL,
+    "image_generation_pony_realism": ImageGenerationPonyRealism,
+    "image_generation_stable_diffusion_3_5": ImageGenerationStableDiffusion35,
+}
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    **_,  # Allow for extra arguments if the loader passes them
+) -> list[VeniceImageBaseTool]:
+    """Get all enabled Venice Image skills based on configuration and privacy level.
+
+    Args:
+        config: The configuration for Venice Image skills.
+        is_private: Whether the context is private (e.g., agent owner).
+
+    Returns:
+        A list of instantiated and enabled Venice Image skill objects.
+    """
+    # Check if the entire category is disabled first
+    if not config.get("enabled", False):
+        return []
+
+    available_skills: list[VeniceImageBaseTool] = []
+
+    # Include skills based on their state
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_venice_image_skill(name, config)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_venice_image_skill(
+    name: str,
+    config: "Config",
+) -> VeniceImageBaseTool | None:
+    """
+    Factory function to get a cached Venice Image skill instance by name.
+
+    Args:
+        name: The name of the skill to get (must match keys in _SKILL_NAME_TO_CLASS_MAP).
+
+    Returns:
+        The requested Venice Image skill instance, or None if the name is unknown.
+    """
+
+    # Return from cache immediately if already exists
+    if name in _cache:
+        return _cache[name]
+
+    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
+    if not skill_class:
+        logger.warning(f"Unknown Venice skill: {name}")
+        return None
+
+    # Cache and return the newly created instance
+    _cache[name] = skill_class()
+    return _cache[name]