intentkit 0.6.9.dev2__py3-none-any.whl → 0.6.10.dev1__py3-none-any.whl

intentkit/skills/venice_audio/venice_audio.py

@@ -1,240 +1,238 @@
-import hashlib
-import json
-import logging
-from typing import Any, Dict, Optional, Type
-
-import httpx
-from langchain_core.runnables import RunnableConfig
-from pydantic import BaseModel, Field
-
-from intentkit.abstracts.skill import SkillStoreABC
-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__)
-
-base_url = "https://api.venice.ai"
-
-
-class VeniceAudioTool(VeniceAudioBaseTool):
-    """
-    Tool for generating audio using the Venice AI Text-to-Speech API (/audio/speech).
-    It requires a specific 'voice_model' to be configured for the instance.
-    Handles API calls, rate limiting, storage, and returns results or API errors as dictionaries.
-
-    On successful audio generation, returns a dictionary with audio details.
-    On Venice API error (non-200 status), returns a dictionary containing
-    the error details from the API response instead of raising an exception.
-    """
-
-    name: str = "venice_audio_text_to_speech"
-    description: str = (
-        "Converts text to speech using a configured Venice AI voice model. "
-        "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."
-    )
-
-    async def _arun(
-        self,
-        input: str,
-        voice_model: str,
-        config: RunnableConfig,
-        speed: Optional[float] = 1.0,
-        response_format: Optional[AllowedAudioFormat] = "mp3",
-        **kwargs,  # type: ignore
-    ) -> 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.
-        Returns a dictionary containing audio details on success, or API error details on failure.
-        """
-        context = self.context_from_config(config)
-        final_response_format = response_format if response_format else "mp3"
-        tts_model_id = "tts-kokoro"  # API model used
-
-        try:
-            # --- Setup Checks ---
-            api_key = self.get_api_key(context)
-
-            _, error_info = self.validate_voice_model(context, voice_model)
-            if error_info:
-                return error_info
-
-            if not api_key:
-                message = (
-                    f"Venice AI API key configuration missing for skill '{self.name}'."
-                )
-                details = f"API key not found for category '{self.category}'. Please configure it."
-                logger.error(message)
-                return {
-                    "error": True,
-                    "error_type": "ConfigurationError",
-                    "message": message,
-                    "details": details,
-                    "voice_model": voice_model,
-                    "requested_format": final_response_format,
-                }
-
-            if not voice_model:
-                message = (
-                    f"Instance of {self.name} was created without a 'voice_model'."
-                )
-                details = "Voice model must be specified for this tool instance."
-                logger.error(message)
-                return {
-                    "error": True,
-                    "error_type": "ConfigurationError",
-                    "message": message,
-                    "details": details,
-                    "voice_model": voice_model,
-                    "requested_format": final_response_format,
-                }
-
-            await self.apply_rate_limit(context)
-
-            # --- Prepare API Call ---
-            payload: Dict[str, Any] = {
-                "model": tts_model_id,
-                "input": input,
-                "voice": voice_model,
-                "response_format": final_response_format,
-                "speed": speed if speed is not None else 1.0,
-                "streaming": False,
-            }
-
-            payload = {k: v for k, v in payload.items() if v is not None}
-
-            logger.debug(
-                f"Venice Audio API Call: Voice='{voice_model}', Format='{final_response_format}', Payload='{payload}'"
-            )
-
-            headers = {
-                "Authorization": f"Bearer {api_key}",
-                "Content-Type": "application/json",
-            }
-            api_url = f"{base_url}/api/v1/audio/speech"
-
-            # --- Execute API Call ---
-            async with httpx.AsyncClient(timeout=120.0) as client:
-                response = await client.post(api_url, json=payload, headers=headers)
-                logger.debug(
-                    f"Venice Audio API Response: Voice='{voice_model}', Format='{final_response_format}', Status={response.status_code}"
-                )
-
-                content_type_header = str(
-                    response.headers.get("content-type", "")
-                ).lower()
-
-                # --- Handle API Success or Error from Response Body ---
-                if response.status_code == 200 and content_type_header.startswith(
-                    "audio/"
-                ):
-                    audio_bytes = response.content
-                    if not audio_bytes:
-                        message = (
-                            "API returned success status but response body was empty."
-                        )
-                        logger.warning(
-                            f"Venice Audio API (Voice: {voice_model}) returned 200 OK but empty audio content."
-                        )
-                        return {
-                            "error": True,
-                            "error_type": "NoContentError",
-                            "message": message,
-                            "status_code": response.status_code,
-                            "voice_model": voice_model,
-                            "requested_format": final_response_format,
-                        }
-
-                    # --- Store Audio ---
-                    file_extension = final_response_format
-                    audio_hash = hashlib.sha256(audio_bytes).hexdigest()
-                    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,
-                        key=key,
-                        file_type=FileType.AUDIO,
-                        size_limit_bytes=size_limit,
-                    )
-
-                    if not stored_url:
-                        message = "Failed to store audio: S3 storage is not configured."
-                        logger.error(
-                            f"Failed to store audio (Voice: {voice_model}): S3 storage is not configured."
-                        )
-                        return {
-                            "error": True,
-                            "error_type": "StorageConfigurationError",
-                            "message": message,
-                            "voice_model": voice_model,
-                            "requested_format": final_response_format,
-                        }
-
-                    logger.info(
-                        f"Venice TTS success: Voice='{voice_model}', Format='{final_response_format}', Stored='{stored_url}'"
-                    )
-                    # --- Return Success Dictionary ---
-                    return {
-                        "audio_url": stored_url,
-                        "audio_bytes_sha256": audio_hash,
-                        "content_type": 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),
-                        "error": False,
-                        "status_code": response.status_code,
-                    }
-                else:
-                    # Non-200 API response or non-audio content
-                    error_details: Any = f"Raw error response text: {response.text}"
-                    try:
-                        parsed_details = response.json()
-                        error_details = parsed_details
-                    except json.JSONDecodeError:
-                        pass  # Keep raw text if JSON parsing fails
-
-                    message = "Venice Audio API returned a non-success status or unexpected content type."
-                    logger.error(
-                        f"Venice Audio API Error: Voice='{voice_model}', Format='{final_response_format}', Status={response.status_code}, Details: {error_details}"
-                    )
-                    return {
-                        "error": True,
-                        "error_type": "APIError",
-                        "message": message,
-                        "status_code": response.status_code,
-                        "details": error_details,
-                        "voice_model": voice_model,
-                        "requested_format": final_response_format,
-                    }
-
-        except Exception as e:
-            # Global exception handling for any uncaught error
-            error_type = type(
-                e
-            ).__name__  # Gets the class name of the exception (e.g., 'TimeoutException', 'ToolException')
-            message = f"An unexpected error occurred during audio generation for voice {voice_model}."
-            details = str(e)  # The string representation of the exception
-
-            # Log the error with full traceback for debugging
-            logger.error(
-                f"Venice Audio Tool Global Error ({error_type}): {message} | Details: {details}",
-                exc_info=True,
-            )
-
-            return {
-                "error": True,
-                "error_type": error_type,  # e.g., "TimeoutException", "ToolException", "ClientError", "ValueError"
-                "message": message,
-                "details": details,
-                "voice_model": voice_model,
-                "requested_format": final_response_format,
-            }
+import hashlib
+import json
+import logging
+from typing import Any, Dict, Optional, Type
+
+import httpx
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+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__)
+
+base_url = "https://api.venice.ai"
+
+
+class VeniceAudioTool(VeniceAudioBaseTool):
+    """
+    Tool for generating audio using the Venice AI Text-to-Speech API (/audio/speech).
+    It requires a specific 'voice_model' to be configured for the instance.
+    Handles API calls, rate limiting, storage, and returns results or API errors as dictionaries.
+
+    On successful audio generation, returns a dictionary with audio details.
+    On Venice API error (non-200 status), returns a dictionary containing
+    the error details from the API response instead of raising an exception.
+    """
+
+    name: str = "venice_audio_text_to_speech"
+    description: str = (
+        "Converts text to speech using a configured Venice AI voice model. "
+        "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."
+    )
+
+    async def _arun(
+        self,
+        input: str,
+        voice_model: str,
+        speed: Optional[float] = 1.0,
+        response_format: Optional[AllowedAudioFormat] = "mp3",
+        **kwargs,  # type: ignore
+    ) -> 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.
+        Returns a dictionary containing audio details on success, or API error details on failure.
+        """
+        context = self.get_context()
+        final_response_format = response_format if response_format else "mp3"
+        tts_model_id = "tts-kokoro"  # API model used
+
+        try:
+            # --- Setup Checks ---
+            api_key = self.get_api_key()
+
+            _, error_info = self.validate_voice_model(context, voice_model)
+            if error_info:
+                return error_info
+
+            if not api_key:
+                message = (
+                    f"Venice AI API key configuration missing for skill '{self.name}'."
+                )
+                details = f"API key not found for category '{self.category}'. Please configure it."
+                logger.error(message)
+                return {
+                    "error": True,
+                    "error_type": "ConfigurationError",
+                    "message": message,
+                    "details": details,
+                    "voice_model": voice_model,
+                    "requested_format": final_response_format,
+                }
+
+            if not voice_model:
+                message = (
+                    f"Instance of {self.name} was created without a 'voice_model'."
+                )
+                details = "Voice model must be specified for this tool instance."
+                logger.error(message)
+                return {
+                    "error": True,
+                    "error_type": "ConfigurationError",
+                    "message": message,
+                    "details": details,
+                    "voice_model": voice_model,
+                    "requested_format": final_response_format,
+                }
+
+            await self.apply_rate_limit(context)
+
+            # --- Prepare API Call ---
+            payload: Dict[str, Any] = {
+                "model": tts_model_id,
+                "input": input,
+                "voice": voice_model,
+                "response_format": final_response_format,
+                "speed": speed if speed is not None else 1.0,
+                "streaming": False,
+            }
+
+            payload = {k: v for k, v in payload.items() if v is not None}
+
+            logger.debug(
+                f"Venice Audio API Call: Voice='{voice_model}', Format='{final_response_format}', Payload='{payload}'"
+            )
+
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            }
+            api_url = f"{base_url}/api/v1/audio/speech"
+
+            # --- Execute API Call ---
+            async with httpx.AsyncClient(timeout=120.0) as client:
+                response = await client.post(api_url, json=payload, headers=headers)
+                logger.debug(
+                    f"Venice Audio API Response: Voice='{voice_model}', Format='{final_response_format}', Status={response.status_code}"
+                )
+
+                content_type_header = str(
+                    response.headers.get("content-type", "")
+                ).lower()
+
+                # --- Handle API Success or Error from Response Body ---
+                if response.status_code == 200 and content_type_header.startswith(
+                    "audio/"
+                ):
+                    audio_bytes = response.content
+                    if not audio_bytes:
+                        message = (
+                            "API returned success status but response body was empty."
+                        )
+                        logger.warning(
+                            f"Venice Audio API (Voice: {voice_model}) returned 200 OK but empty audio content."
+                        )
+                        return {
+                            "error": True,
+                            "error_type": "NoContentError",
+                            "message": message,
+                            "status_code": response.status_code,
+                            "voice_model": voice_model,
+                            "requested_format": final_response_format,
+                        }
+
+                    # --- Store Audio ---
+                    file_extension = final_response_format
+                    audio_hash = hashlib.sha256(audio_bytes).hexdigest()
+                    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,
+                        key=key,
+                        file_type=FileType.AUDIO,
+                        size_limit_bytes=size_limit,
+                    )
+
+                    if not stored_url:
+                        message = "Failed to store audio: S3 storage is not configured."
+                        logger.error(
+                            f"Failed to store audio (Voice: {voice_model}): S3 storage is not configured."
+                        )
+                        return {
+                            "error": True,
+                            "error_type": "StorageConfigurationError",
+                            "message": message,
+                            "voice_model": voice_model,
+                            "requested_format": final_response_format,
+                        }
+
+                    logger.info(
+                        f"Venice TTS success: Voice='{voice_model}', Format='{final_response_format}', Stored='{stored_url}'"
+                    )
+                    # --- Return Success Dictionary ---
+                    return {
+                        "audio_url": stored_url,
+                        "audio_bytes_sha256": audio_hash,
+                        "content_type": 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),
+                        "error": False,
+                        "status_code": response.status_code,
+                    }
+                else:
+                    # Non-200 API response or non-audio content
+                    error_details: Any = f"Raw error response text: {response.text}"
+                    try:
+                        parsed_details = response.json()
+                        error_details = parsed_details
+                    except json.JSONDecodeError:
+                        pass  # Keep raw text if JSON parsing fails
+
+                    message = "Venice Audio API returned a non-success status or unexpected content type."
+                    logger.error(
+                        f"Venice Audio API Error: Voice='{voice_model}', Format='{final_response_format}', Status={response.status_code}, Details: {error_details}"
+                    )
+                    return {
+                        "error": True,
+                        "error_type": "APIError",
+                        "message": message,
+                        "status_code": response.status_code,
+                        "details": error_details,
+                        "voice_model": voice_model,
+                        "requested_format": final_response_format,
+                    }
+
+        except Exception as e:
+            # Global exception handling for any uncaught error
+            error_type = type(
+                e
+            ).__name__  # Gets the class name of the exception (e.g., 'TimeoutException', 'ToolException')
+            message = f"An unexpected error occurred during audio generation for voice {voice_model}."
+            details = str(e)  # The string representation of the exception
+
+            # Log the error with full traceback for debugging
+            logger.error(
+                f"Venice Audio Tool Global Error ({error_type}): {message} | Details: {details}",
+                exc_info=True,
+            )
+
+            return {
+                "error": True,
+                "error_type": error_type,  # e.g., "TimeoutException", "ToolException", "ClientError", "ValueError"
+                "message": message,
+                "details": details,
+                "voice_model": voice_model,
+                "requested_format": final_response_format,
+            }

intentkit/skills/venice_image/base.py

@@ -1,14 +1,11 @@
 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,
-    SkillContext,
-    ToolException,
-)
+from intentkit.skills.base import IntentKitSkill
 from intentkit.skills.venice_image.api import (
     make_venice_api_request,
 )
@@ -47,7 +44,7 @@ class VeniceImageBaseTool(IntentKitSkill):
         description="The skill store for persisting data and configs."
     )
 
-    def getSkillConfig(self, context: SkillContext) -> VeniceImageConfig:
+    def getSkillConfig(self, context) -> VeniceImageConfig:
         """
         Creates a VeniceImageConfig instance from a dictionary of configuration values.
 
@@ -58,19 +55,20 @@ class VeniceImageBaseTool(IntentKitSkill):
             A VeniceImageConfig object.
         """
 
+        skill_config = context.agent.skill_config(self.category)
         return VeniceImageConfig(
-            api_key_provider=context.config.get("api_key_provider", "agent_owner"),
-            safe_mode=context.config.get("safe_mode", True),
-            hide_watermark=context.config.get("hide_watermark", True),
-            embed_exif_metadata=context.config.get("embed_exif_metadata", False),
-            negative_prompt=context.config.get(
+            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=context.config.get("rate_limit_number"),
-            rate_limit_minutes=context.config.get("rate_limit_minutes"),
+            rate_limit_number=skill_config.get("rate_limit_number"),
+            rate_limit_minutes=skill_config.get("rate_limit_minutes"),
         )
 
-    def get_api_key(self, context: SkillContext) -> str:
+    def get_api_key(self) -> str:
         """
         Retrieves the Venice AI API key based on the api_key_provider setting.
 
@@ -81,9 +79,11 @@ class VeniceImageBaseTool(IntentKitSkill):
             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":
-                agent_api_key = context.config.get("api_key")
+                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}"
@@ -112,7 +112,7 @@ class VeniceImageBaseTool(IntentKitSkill):
         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: SkillContext) -> None:
+    async def apply_venice_rate_limit(self, context) -> None:
         """
         Applies rate limiting to prevent exceeding the Venice AI API's rate limits.
 
@@ -121,7 +121,7 @@ class VeniceImageBaseTool(IntentKitSkill):
             - 'platform': uses system-wide configuration.
         """
         try:
-            user_id = context.user_id
+            # 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":
@@ -129,6 +129,8 @@ class VeniceImageBaseTool(IntentKitSkill):
                 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}"
                     )
@@ -145,6 +147,8 @@ class VeniceImageBaseTool(IntentKitSkill):
                 )
 
                 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}"
                     )
@@ -158,7 +162,7 @@ class VeniceImageBaseTool(IntentKitSkill):
             raise ToolException(f"Failed to apply Venice rate limit: {str(e)}") from e
 
     async def post(
-        self, path: str, payload: Dict[str, Any], context: SkillContext
+        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`
@@ -181,7 +185,7 @@ class VeniceImageBaseTool(IntentKitSkill):
             - 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(context)
+        api_key = self.get_api_key()
 
         return await make_venice_api_request(
             api_key, path, payload, self.category, self.name