intentkit 0.7.5.dev12__tar.gz → 0.7.5.dev13__tar.gz

{intentkit-0.7.5.dev12 → intentkit-0.7.5.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.7.5.dev12
+Version: 0.7.5.dev13
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestalnetwork/intentkit
 Project-URL: Repository, https://github.com/crestalnetwork/intentkit

{intentkit-0.7.5.dev12 → intentkit-0.7.5.dev13}/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.7.5-dev12"
+__version__ = "0.7.5-dev13"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

{intentkit-0.7.5.dev12 → intentkit-0.7.5.dev13}/models/agent.py

@@ -1415,16 +1415,7 @@ class Agent(AgentCreate, AgentPublicInfo):
                 skills_properties = skills_property.get("properties", {})
 
                 if skills_properties:
-                    # Load all skills from the database
-                    # Query all skills grouped by category with enabled status
-                    stmt = select(
-                        SkillTable.category,
-                        func.bool_or(SkillTable.enabled).label("any_enabled"),
-                    ).group_by(SkillTable.category)
-                    result = await db.execute(stmt)
-                    category_status = {row.category: row.any_enabled for row in result}
-
-                    # Query all skills with their price levels for adding x-price-level fields
+                    # Query all enabled skills with their price levels for adding x-price-level fields
                     skills_stmt = select(
                         SkillTable.category,
                         SkillTable.config_name,
@@ -1434,8 +1425,12 @@ class Agent(AgentCreate, AgentPublicInfo):
                     skills_result = await db.execute(skills_stmt)
                     skills_data = {}
                     category_price_levels = {}
+                    enabled_categories = set()
 
                     for row in skills_result:
+                        # Collect enabled categories using a set for deduplication
+                        enabled_categories.add(row.category)
+
                         if row.category not in skills_data:
                             skills_data[row.category] = {}
                             category_price_levels[row.category] = []
@@ -1458,11 +1453,8 @@ class Agent(AgentCreate, AgentPublicInfo):
 
                     # Process each skill in the schema
                     for skill_category in skill_keys:
-                        if skill_category not in category_status:
-                            # If category not found in database, remove it from schema
-                            skills_properties.pop(skill_category, None)
-                        elif not category_status[skill_category]:
-                            # If category exists but all skills are disabled, remove it
+                        if skill_category not in enabled_categories:
+                            # If category not found in enabled categories, remove it from schema
                             skills_properties.pop(skill_category, None)
                         elif filter_owner_api_skills and cls._is_agent_owner_only_skill(
                             skills_properties[skill_category]

{intentkit-0.7.5.dev12 → intentkit-0.7.5.dev13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.7.5-dev12"
+version = "0.7.5-dev13"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"

{intentkit-0.7.5.dev12 → intentkit-0.7.5.dev13}/skills/venice_audio/venice_audio.py

@@ -9,7 +9,7 @@ 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
+from intentkit.utils.s3 import store_file
 
 logger = logging.getLogger(__name__)
 
@@ -48,7 +48,7 @@ class VeniceAudioTool(VeniceAudioBaseTool):
     ) -> 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()
@@ -155,11 +155,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,7 +203,7 @@ 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,

{intentkit-0.7.5.dev12 → intentkit-0.7.5.dev13}/utils/s3.py

@@ -182,6 +182,59 @@ class FileType(str, Enum):
     PDF = "pdf"
 
 
+async def store_file(
+    content: bytes,
+    key: str,
+    content_type: Optional[str] = None,
+    size: Optional[int] = None,
+) -> str:
+    """Store raw file bytes with automatic content type detection."""
+    if not _client or not _bucket or not _prefix or not _cdn_url:
+        logger.info("S3 not initialized. Cannot store file bytes.")
+        return ""
+
+    if not content:
+        raise ValueError("File content cannot be empty")
+
+    actual_size = len(content)
+    if size is not None and size != actual_size:
+        raise ValueError(
+            f"Provided size {size} does not match actual content size {actual_size} bytes"
+        )
+
+    effective_size = size if size is not None else actual_size
+
+    detected_content_type = content_type
+    if not detected_content_type:
+        kind = filetype.guess(content)
+        detected_content_type = (
+            kind.mime if kind and kind.mime else "application/octet-stream"
+        )
+
+    prefixed_key = f"{_prefix}{key}"
+    file_obj = BytesIO(content)
+
+    logger.info(
+        "Uploading file to S3 with content type %s and size %s bytes",
+        detected_content_type,
+        effective_size,
+    )
+
+    _client.upload_fileobj(
+        file_obj,
+        _bucket,
+        prefixed_key,
+        ExtraArgs={
+            "ContentType": detected_content_type,
+            "ContentDisposition": "inline",
+        },
+    )
+
+    cdn_url = f"{_cdn_url}/{prefixed_key}"
+    logger.info("File uploaded successfully to %s", cdn_url)
+    return cdn_url
+
+
 async def store_file_bytes(
     file_bytes: bytes,
     key: str,